diff --git a/src/client/inc/tscUtil.h b/src/client/inc/tscUtil.h
index afbbd1d24b5d69b8559c857f29c438c09ca0cffd..42959ade3c940cd27b2c04512eddfdd4e55e371f 100644
--- a/src/client/inc/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@@ -141,7 +141,7 @@ bool tscQueryTags(SQueryInfo* pQueryInfo);
 SSqlExpr* tscAddSpecialColumnForSelect(SQueryInfo* pQueryInfo, int32_t outputColIndex, int16_t functionId,
                                        SColumnIndex* pIndex, SSchema* pColSchema, int16_t colType);
 
-int32_t tscSetTableFullName(STableMetaInfo* pTableMetaInfo, SSQLToken* pzTableName, SSqlObj* pSql);
+int32_t tscSetTableFullName(STableMetaInfo* pTableMetaInfo, SStrToken* pzTableName, SSqlObj* pSql);
 void    tscClearInterpInfo(SQueryInfo* pQueryInfo);
 
 bool tscIsInsertData(char* sqlstr);
@@ -194,7 +194,7 @@ SColumn* tscColumnListInsert(SArray* pColList, SColumnIndex* colIndex);
 SArray* tscColumnListClone(const SArray* src, int16_t tableIndex);
 void tscColumnListDestroy(SArray* pColList);
 
-int32_t tscValidateName(SSQLToken* pToken);
+int32_t tscValidateName(SStrToken* pToken);
 
 void tscIncStreamExecutionCount(void* pStream);
 
diff --git a/src/client/src/tscParseInsert.c b/src/client/src/tscParseInsert.c
index cb49bd80b7720f74e751945f6202024ee26587f6..939ebb6abe7b97ed6e55937d0083e5ccd8e050c4 100644
--- a/src/client/src/tscParseInsert.c
+++ b/src/client/src/tscParseInsert.c
@@ -40,7 +40,7 @@ enum {
 
 static int32_t tscAllocateMemIfNeed(STableDataBlocks *pDataBlock, int32_t rowSize, int32_t * numOfRows);
 
-static int32_t tscToInteger(SSQLToken *pToken, int64_t *value, char **endPtr) {
+static int32_t tscToInteger(SStrToken *pToken, int64_t *value, char **endPtr) {
   if (pToken->n == 0) {
     return TK_ILLEGAL;
   }
@@ -73,7 +73,7 @@ static int32_t tscToInteger(SSQLToken *pToken, int64_t *value, char **endPtr) {
   return pToken->type;
 }
 
-static int32_t tscToDouble(SSQLToken *pToken, double *value, char **endPtr) {
+static int32_t tscToDouble(SStrToken *pToken, double *value, char **endPtr) {
   if (pToken->n == 0) {
     return TK_ILLEGAL;
   }
@@ -89,9 +89,9 @@ static int32_t tscToDouble(SSQLToken *pToken, double *value, char **endPtr) {
   return pToken->type;
 }
 
-int tsParseTime(SSQLToken *pToken, int64_t *time, char **next, char *error, int16_t timePrec) {
+int tsParseTime(SStrToken *pToken, int64_t *time, char **next, char *error, int16_t timePrec) {
   int32_t   index = 0;
-  SSQLToken sToken;
+  SStrToken sToken;
   int64_t   interval;
   int64_t   useconds = 0;
   char *    pTokenEnd = *next;
@@ -128,7 +128,7 @@ int tsParseTime(SSQLToken *pToken, int64_t *time, char **next, char *error, int1
    * time expression:
    * e.g., now+12a, now-5h
    */
-  SSQLToken valueToken;
+  SStrToken valueToken;
   index = 0;
   sToken = tStrGetToken(pTokenEnd, &index, false, 0, NULL);
   pTokenEnd += index;
@@ -163,7 +163,7 @@ int tsParseTime(SSQLToken *pToken, int64_t *time, char **next, char *error, int1
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t tsParseOneColumnData(SSchema *pSchema, SSQLToken *pToken, char *payload, char *msg, char **str, bool primaryKey,
+int32_t tsParseOneColumnData(SSchema *pSchema, SStrToken *pToken, char *payload, char *msg, char **str, bool primaryKey,
                              int16_t timePrec) {
   int64_t iv;
   int32_t numType;
@@ -409,7 +409,7 @@ static int32_t tsCheckTimestamp(STableDataBlocks *pDataBlocks, const char *start
 int tsParseOneRowData(char **str, STableDataBlocks *pDataBlocks, SSchema schema[], SParsedDataColInfo *spd, char *error,
                       int16_t timePrec, int32_t *code, char *tmpTokenBuf) {
   int32_t index = 0;
-  SSQLToken sToken = {0};
+  SStrToken sToken = {0};
   char *    payload = pDataBlocks->pData + pDataBlocks->size;
 
   // 1. set the parsed value from sql string
@@ -524,7 +524,7 @@ static int32_t rowDataCompar(const void *lhs, const void *rhs) {
 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;
+  SStrToken sToken;
 
   int16_t numOfRows = 0;
 
@@ -734,8 +734,8 @@ static int32_t doParseInsertStatement(SSqlObj *pSql, void *pTableList, char **st
 
 static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
   int32_t   index = 0;
-  SSQLToken sToken = {0};
-  SSQLToken tableToken = {0};
+  SStrToken sToken = {0};
+  SStrToken tableToken = {0};
   int32_t   code = TSDB_CODE_SUCCESS;
   
   const int32_t TABLE_INDEX = 0;
@@ -993,7 +993,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
   return code;
 }
 
-int validateTableName(char *tblName, int len, SSQLToken* psTblToken) {
+int validateTableName(char *tblName, int len, SStrToken* psTblToken) {
   tstrncpy(psTblToken->z, tblName, TSDB_TABLE_FNAME_LEN);
 
   psTblToken->n    = len;
@@ -1057,7 +1057,7 @@ int tsParseInsertSql(SSqlObj *pSql) {
 
   while (1) {
     int32_t   index = 0;
-    SSQLToken sToken = tStrGetToken(str, &index, false, 0, NULL);
+    SStrToken sToken = tStrGetToken(str, &index, false, 0, NULL);
 
     // no data in the sql string anymore.
     if (sToken.n == 0) {
@@ -1083,7 +1083,7 @@ int tsParseInsertSql(SSqlObj *pSql) {
 
     pCmd->curSql = sToken.z;
     char buf[TSDB_TABLE_FNAME_LEN];
-    SSQLToken sTblToken;
+    SStrToken sTblToken;
     sTblToken.z = buf;
     // Check if the table name available or not
     if (validateTableName(sToken.z, sToken.n, &sTblToken) != TSDB_CODE_SUCCESS) {
@@ -1285,7 +1285,7 @@ int tsInsertInitialCheck(SSqlObj *pSql) {
   int32_t  index = 0;
   SSqlCmd *pCmd = &pSql->cmd;
 
-  SSQLToken sToken = tStrGetToken(pSql->sqlstr, &index, false, 0, NULL);
+  SStrToken sToken = tStrGetToken(pSql->sqlstr, &index, false, 0, NULL);
   assert(sToken.type == TK_INSERT || sToken.type == TK_IMPORT);
 
   pCmd->count = 0;
diff --git a/src/client/src/tscPrepare.c b/src/client/src/tscPrepare.c
index b996dd958ae432300391a104f94a4cfe27f0858d..620e8ea57a29c75f1060ee4de6f1661ae319f07d 100644
--- a/src/client/src/tscPrepare.c
+++ b/src/client/src/tscPrepare.c
@@ -155,7 +155,7 @@ static int normalStmtPrepare(STscStmt* stmt) {
   uint32_t i = 0, start = 0;
 
   while (sql[i] != 0) {
-    SSQLToken token = {0};
+    SStrToken token = {0};
     token.n = tSQLGetToken(sql + i, &token.type);
 
     if (token.type == TK_QUESTION) {
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 995a64ebe840d07a36a4272ee058ed94960b3975..bc2b2672d3751499019f397d1dcbadf82c2eb3d6 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -51,12 +51,12 @@ static int32_t setShowInfo(SSqlObj* pSql, SSqlInfo* pInfo);
 static char*   getAccountId(SSqlObj* pSql);
 
 static bool has(tFieldList* pFieldList, int32_t startIdx, const char* name);
-static void getCurrentDBName(SSqlObj* pSql, SSQLToken* pDBToken);
-static bool hasSpecifyDB(SSQLToken* pTableName);
+static void getCurrentDBName(SSqlObj* pSql, SStrToken* pDBToken);
+static bool hasSpecifyDB(SStrToken* pTableName);
 static bool validateTableColumnInfo(tFieldList* pFieldList, SSqlCmd* pCmd);
 static bool validateTagParams(tFieldList* pTagsList, tFieldList* pFieldList, SSqlCmd* pCmd);
 
-static int32_t setObjFullName(char* fullName, const char* account, SSQLToken* pDB, SSQLToken* tableName, int32_t* len);
+static int32_t setObjFullName(char* fullName, const char* account, SStrToken* pDB, SStrToken* tableName, int32_t* len);
 
 static void getColumnName(tSQLExprItem* pItem, char* resultFieldName, int32_t nameLength);
 static void getRevisedName(char* resultFieldName, int32_t functionId, int32_t maxLen, char* columnName);
@@ -100,11 +100,11 @@ static bool hasTimestampForPointInterpQuery(SQueryInfo* pQueryInfo);
 
 static int32_t parseLimitClause(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t index, SQuerySQL* pQuerySql, SSqlObj* pSql);
 static int32_t parseCreateDBOptions(SSqlCmd* pCmd, SCreateDBInfo* pCreateDbSql);
-static int32_t getColumnIndexByName(SSqlCmd* pCmd, const SSQLToken* pToken, SQueryInfo* pQueryInfo, SColumnIndex* pIndex);
-static int32_t getTableIndexByName(SSQLToken* pToken, SQueryInfo* pQueryInfo, SColumnIndex* pIndex);
+static int32_t getColumnIndexByName(SSqlCmd* pCmd, const SStrToken* pToken, SQueryInfo* pQueryInfo, SColumnIndex* pIndex);
+static int32_t getTableIndexByName(SStrToken* pToken, SQueryInfo* pQueryInfo, SColumnIndex* pIndex);
 static int32_t optrToString(tSQLExpr* pExpr, char** exprString);
 
-static int32_t getTableIndexImpl(SSQLToken* pTableToken, SQueryInfo* pQueryInfo, SColumnIndex* pIndex);
+static int32_t getTableIndexImpl(SStrToken* pTableToken, SQueryInfo* pQueryInfo, SColumnIndex* pIndex);
 static int32_t doFunctionsCompatibleCheck(SSqlCmd* pCmd, SQueryInfo* pQueryInfo);
 static int32_t doLocalQueryProcess(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SQuerySQL* pQuerySql);
 static int32_t tscCheckCreateDbParams(SSqlCmd* pCmd, SCMCreateDbMsg* pCreate);
@@ -151,7 +151,7 @@ static int setColumnFilterInfoForTimestamp(SSqlCmd* pCmd, SQueryInfo* pQueryInfo
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t handlePassword(SSqlCmd* pCmd, SSQLToken* pPwd) {
+static int32_t handlePassword(SSqlCmd* pCmd, SStrToken* pPwd) {
   const char* msg1 = "password can not be empty";
   const char* msg2 = "name or password too long";
   const char* msg3 = "password needs single quote marks enclosed";
@@ -206,7 +206,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       const char* msg2 = "invalid name";
       const char* msg3 = "param name too long";
 
-      SSQLToken* pzName = &pInfo->pDCLInfo->a[0];
+      SStrToken* pzName = &pInfo->pDCLInfo->a[0];
       if ((pInfo->type != TSDB_SQL_DROP_DNODE) && (tscValidateName(pzName) != TSDB_CODE_SUCCESS)) {
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
       }
@@ -241,7 +241,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 
     case TSDB_SQL_USE_DB: {
       const char* msg = "invalid db name";
-      SSQLToken*  pToken = &pInfo->pDCLInfo->a[0];
+      SStrToken*  pToken = &pInfo->pDCLInfo->a[0];
 
       if (tscValidateName(pToken) != TSDB_CODE_SUCCESS) {
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
@@ -296,7 +296,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
       }
 
-      SSQLToken* pIpAddr = &pInfo->pDCLInfo->a[0];
+      SStrToken* pIpAddr = &pInfo->pDCLInfo->a[0];
       pIpAddr->n = strdequote(pIpAddr->z);
       break;
     }
@@ -307,8 +307,8 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       const char* msg2 = "invalid user/account name";
       const char* msg3 = "name too long";
 
-      SSQLToken* pName = &pInfo->pDCLInfo->user.user;
-      SSQLToken* pPwd = &pInfo->pDCLInfo->user.passwd;
+      SStrToken* pName = &pInfo->pDCLInfo->user.user;
+      SStrToken* pPwd = &pInfo->pDCLInfo->user.passwd;
 
       if (handlePassword(pCmd, pPwd) != TSDB_CODE_SUCCESS) {
         return TSDB_CODE_TSC_INVALID_SQL;
@@ -337,7 +337,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     }
 
     case TSDB_SQL_DESCRIBE_TABLE: {
-      SSQLToken*  pToken = &pInfo->pDCLInfo->a[0];
+      SStrToken*  pToken = &pInfo->pDCLInfo->a[0];
       const char* msg2 = "table name is too long";
       const char* msg1 = "invalid table name";
 
@@ -400,8 +400,8 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       // tDCLSQL* pDCL = pInfo->pDCLInfo;
 
       SUserInfo* pUser = &pInfo->pDCLInfo->user;
-      SSQLToken* pName = &pUser->user;
-      SSQLToken* pPwd = &pUser->passwd;
+      SStrToken* pName = &pUser->user;
+      SStrToken* pPwd = &pUser->passwd;
 
       if (pName->n >= TSDB_USER_LEN) {
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
@@ -423,7 +423,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
         } else if (pUser->type == TSDB_ALTER_USER_PRIVILEGES) {
           assert(pPwd->type == TSDB_DATA_TYPE_NULL);
 
-          SSQLToken* pPrivilege = &pUser->privilege;
+          SStrToken* pPrivilege = &pUser->privilege;
 
           if (strncasecmp(pPrivilege->z, "super", 5) == 0 && pPrivilege->n == 5) {
             pCmd->count = 1;
@@ -581,7 +581,7 @@ int32_t parseIntervalClause(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SQuerySQL* pQ
   }
 
   // interval is not null
-  SSQLToken* t = &pQuerySql->interval;
+  SStrToken* t = &pQuerySql->interval;
   if (getTimestampInUsFromStr(t->z, t->n, &pQueryInfo->intervalTime) != TSDB_CODE_SUCCESS) {
     return TSDB_CODE_TSC_INVALID_SQL;
   }
@@ -667,7 +667,7 @@ int32_t parseSlidingClause(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SQuerySQL* pQu
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
   STableComInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
 
-  SSQLToken* pSliding = &pQuerySql->sliding;
+  SStrToken* pSliding = &pQuerySql->sliding;
   if (pSliding->n != 0) {
     getTimestampInUsFromStr(pSliding->z, pSliding->n, &pQueryInfo->slidingTime);
     if (tinfo.precision == TSDB_TIME_PRECISION_MILLI) {
@@ -692,7 +692,7 @@ int32_t parseSlidingClause(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SQuerySQL* pQu
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t tscSetTableFullName(STableMetaInfo* pTableMetaInfo, SSQLToken* pzTableName, SSqlObj* pSql) {
+int32_t tscSetTableFullName(STableMetaInfo* pTableMetaInfo, SStrToken* pzTableName, SSqlObj* pSql) {
   const char* msg = "name too long";
 
   SSqlCmd* pCmd = &pSql->cmd;
@@ -709,7 +709,7 @@ int32_t tscSetTableFullName(STableMetaInfo* pTableMetaInfo, SSQLToken* pzTableNa
     // db has been specified in sql string so we ignore current db path
     code = setObjFullName(pTableMetaInfo->name, getAccountId(pSql), NULL, pzTableName, NULL);
   } else {  // get current DB name first, then set it into path
-    SSQLToken t = {0};
+    SStrToken t = {0};
     getCurrentDBName(pSql, &t);
 
     code = setObjFullName(pTableMetaInfo->name, NULL, &t, pzTableName, NULL);
@@ -1027,13 +1027,13 @@ static bool has(tFieldList* pFieldList, int32_t startIdx, const char* name) {
 
 static char* getAccountId(SSqlObj* pSql) { return pSql->pTscObj->acctId; }
 
-static void getCurrentDBName(SSqlObj* pSql, SSQLToken* pDBToken) {
+static void getCurrentDBName(SSqlObj* pSql, SStrToken* pDBToken) {
   pDBToken->z = pSql->pTscObj->db;
   pDBToken->n = (uint32_t)strlen(pSql->pTscObj->db);
 }
 
 /* length limitation, strstr cannot be applied */
-static bool hasSpecifyDB(SSQLToken* pTableName) {
+static bool hasSpecifyDB(SStrToken* pTableName) {
   for (uint32_t i = 0; i < pTableName->n; ++i) {
     if (pTableName->z[i] == TS_PATH_DELIMITER[0]) {
       return true;
@@ -1043,7 +1043,7 @@ static bool hasSpecifyDB(SSQLToken* pTableName) {
   return false;
 }
 
-int32_t setObjFullName(char* fullName, const char* account, SSQLToken* pDB, SSQLToken* tableName, int32_t* xlen) {
+int32_t setObjFullName(char* fullName, const char* account, SStrToken* pDB, SStrToken* tableName, int32_t* xlen) {
   int32_t totalLen = 0;
 
   if (account != NULL) {
@@ -1463,7 +1463,7 @@ int32_t addProjectionExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, t
     index.columnIndex = (pQueryInfo->udColumnId--);
     index.tableIndex = 0;
 
-    SSchema colSchema = tGetUserSpecifiedColumnSchema(&pItem->pNode->val, pItem->aliasName);
+    SSchema colSchema = tGetUserSpecifiedColumnSchema(&pItem->pNode->val, &pItem->pNode->token, pItem->aliasName);
     SSqlExpr* pExpr =
         tscAddSpecialColumnForSelect(pQueryInfo, startPos, TSDB_FUNC_PRJ, &index, &colSchema, TSDB_COL_UDC);
 
@@ -1489,6 +1489,7 @@ int32_t addProjectionExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, t
       }
 
       addProjectQueryCol(pQueryInfo, startPos, &index, pItem);
+      pQueryInfo->type |= TSDB_QUERY_TYPE_PROJECTION_QUERY;
     }
 
     // add the primary timestamp column even though it is not required by user
@@ -1579,7 +1580,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
       SColumnIndex index = COLUMN_INDEX_INITIALIZER;
 
       if (pItem->pNode->pParam != NULL) {
-        SSQLToken* pToken = &pItem->pNode->pParam->a[0].pNode->colInfo;
+        SStrToken* pToken = &pItem->pNode->pParam->a[0].pNode->colInfo;
         if (pToken->z == NULL || pToken->n == 0) {
           return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
         }
@@ -1588,7 +1589,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
         if (pParamElem->pNode->nSQLOptr == TK_ALL) {
           // select table.*
           // check if the table name is valid or not
-          SSQLToken tmpToken = pParamElem->pNode->colInfo;
+          SStrToken tmpToken = pParamElem->pNode->colInfo;
 
           if (getTableIndexByName(&tmpToken, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
             return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
@@ -1786,7 +1787,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
 
           if (pParamElem->pNode->nSQLOptr == TK_ALL) {
             // select table.*
-            SSQLToken tmpToken = pParamElem->pNode->colInfo;
+            SStrToken tmpToken = pParamElem->pNode->colInfo;
 
             if (getTableIndexByName(&tmpToken, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
               return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
@@ -2088,16 +2089,16 @@ void getRevisedName(char* resultFieldName, int32_t functionId, int32_t maxLen, c
   snprintf(resultFieldName, maxLen, "%s(%s)", aAggs[functionId].aName, columnName);
 }
 
-static bool isTablenameToken(SSQLToken* token) {
-  SSQLToken tmpToken = *token;
-  SSQLToken tableToken = {0};
+static bool isTablenameToken(SStrToken* token) {
+  SStrToken tmpToken = *token;
+  SStrToken tableToken = {0};
 
   extractTableNameFromToken(&tmpToken, &tableToken);
 
   return (strncasecmp(TSQL_TBNAME_L, tmpToken.z, tmpToken.n) == 0 && tmpToken.n == strlen(TSQL_TBNAME_L));
 }
 
-static int16_t doGetColumnIndex(SQueryInfo* pQueryInfo, int32_t index, SSQLToken* pToken) {
+static int16_t doGetColumnIndex(SQueryInfo* pQueryInfo, int32_t index, SStrToken* pToken) {
   STableMeta* pTableMeta = tscGetMetaInfo(pQueryInfo, index)->pTableMeta;
 
   int32_t  numOfCols = tscGetNumOfColumns(pTableMeta) + tscGetNumOfTags(pTableMeta);
@@ -2119,7 +2120,7 @@ static int16_t doGetColumnIndex(SQueryInfo* pQueryInfo, int32_t index, SSQLToken
   return columnIndex;
 }
 
-int32_t doGetColumnIndexByName(SSqlCmd* pCmd, SSQLToken* pToken, SQueryInfo* pQueryInfo, SColumnIndex* pIndex) {
+int32_t doGetColumnIndexByName(SSqlCmd* pCmd, SStrToken* pToken, SQueryInfo* pQueryInfo, SColumnIndex* pIndex) {
   const char* msg0 = "ambiguous column name";
   const char* msg1 = "invalid column name";
 
@@ -2161,7 +2162,7 @@ int32_t doGetColumnIndexByName(SSqlCmd* pCmd, SSQLToken* pToken, SQueryInfo* pQu
   }
 }
 
-int32_t getTableIndexImpl(SSQLToken* pTableToken, SQueryInfo* pQueryInfo, SColumnIndex* pIndex) {
+int32_t getTableIndexImpl(SStrToken* pTableToken, SQueryInfo* pQueryInfo, SColumnIndex* pIndex) {
   if (pTableToken->n == 0) {  // only one table and no table name prefix in column name
     if (pQueryInfo->numOfTables == 1) {
       pIndex->tableIndex = 0;
@@ -2187,8 +2188,8 @@ int32_t getTableIndexImpl(SSQLToken* pTableToken, SQueryInfo* pQueryInfo, SColum
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t getTableIndexByName(SSQLToken* pToken, SQueryInfo* pQueryInfo, SColumnIndex* pIndex) {
-  SSQLToken tableToken = {0};
+int32_t getTableIndexByName(SStrToken* pToken, SQueryInfo* pQueryInfo, SColumnIndex* pIndex) {
+  SStrToken tableToken = {0};
   extractTableNameFromToken(pToken, &tableToken);
 
   if (getTableIndexImpl(&tableToken, pQueryInfo, pIndex) != TSDB_CODE_SUCCESS) {
@@ -2198,12 +2199,12 @@ int32_t getTableIndexByName(SSQLToken* pToken, SQueryInfo* pQueryInfo, SColumnIn
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t getColumnIndexByName(SSqlCmd* pCmd, const SSQLToken* pToken, SQueryInfo* pQueryInfo, SColumnIndex* pIndex) {
+int32_t getColumnIndexByName(SSqlCmd* pCmd, const SStrToken* pToken, SQueryInfo* pQueryInfo, SColumnIndex* pIndex) {
   if (pQueryInfo->pTableMetaInfo == NULL || pQueryInfo->numOfTables == 0) {
     return TSDB_CODE_TSC_INVALID_SQL;
   }
 
-  SSQLToken tmpToken = *pToken;
+  SStrToken tmpToken = *pToken;
 
   if (getTableIndexByName(&tmpToken, pQueryInfo, pIndex) != TSDB_CODE_SUCCESS) {
     return TSDB_CODE_TSC_INVALID_SQL;
@@ -2315,7 +2316,7 @@ int32_t setShowInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
   int16_t    showType = pShowInfo->showType;
   if (showType == TSDB_MGMT_TABLE_TABLE || showType == TSDB_MGMT_TABLE_METRIC || showType == TSDB_MGMT_TABLE_VGROUP) {
     // db prefix in tagCond, show table conds in payload
-    SSQLToken* pDbPrefixToken = &pShowInfo->prefix;
+    SStrToken* pDbPrefixToken = &pShowInfo->prefix;
     if (pDbPrefixToken->type != 0) {
 
       if (pDbPrefixToken->n >= TSDB_DB_NAME_LEN) {  // db name is too long
@@ -2337,7 +2338,7 @@ int32_t setShowInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     }
 
     // show table/stable like 'xxxx', set the like pattern for show tables
-    SSQLToken* pPattern = &pShowInfo->pattern;
+    SStrToken* pPattern = &pShowInfo->pattern;
     if (pPattern->type != 0) {
       pPattern->n = strdequote(pPattern->z);
 
@@ -2355,7 +2356,7 @@ int32_t setShowInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     }
 
     // show vnodes may be ip addr of dnode in payload
-    SSQLToken* pDnodeIp = &pShowInfo->prefix;
+    SStrToken* pDnodeIp = &pShowInfo->prefix;
     if (pDnodeIp->n >= TSDB_IPv4ADDR_LEN) {  // ip addr is too long
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
     }
@@ -2376,7 +2377,7 @@ int32_t setKillInfo(SSqlObj* pSql, struct SSqlInfo* pInfo, int32_t killType) {
   SSqlCmd* pCmd = &pSql->cmd;
   pCmd->command = pInfo->type;
   
-  SSQLToken* idStr = &(pInfo->pDCLInfo->ip);
+  SStrToken* idStr = &(pInfo->pDCLInfo->ip);
   if (idStr->n > TSDB_KILL_MSG_LEN) {
     return TSDB_CODE_TSC_INVALID_SQL;
   }
@@ -2597,7 +2598,7 @@ int32_t parseGroupbyClause(SQueryInfo* pQueryInfo, tVariantList* pList, SSqlCmd*
   
   for (int32_t i = 0; i < pList->nExpr; ++i) {
     tVariant* pVar = &pList->a[i].pVar;
-    SSQLToken token = {pVar->nLen, pVar->nType, pVar->pz};
+    SStrToken token = {pVar->nLen, pVar->nType, pVar->pz};
 
     SColumnIndex index = COLUMN_INDEX_INITIALIZER;
     if (getColumnIndexByName(pCmd, &token, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
@@ -3623,7 +3624,7 @@ static void doExtractExprForSTable(SSqlCmd* pCmd, tSQLExpr** pExpr, SQueryInfo*
       return;
     }
 
-    SSQLToken t = {0};
+    SStrToken t = {0};
     extractTableNameFromToken(&pLeft->colInfo, &t);
 
     *pOut = *pExpr;
@@ -3703,7 +3704,7 @@ static int32_t setTableCondForSTableQuery(SSqlCmd* pCmd, SQueryInfo* pQueryInfo,
   num = j;
 
   char* name = extractDBName(pTableMetaInfo->name, db);
-  SSQLToken dbToken = { .type = TK_STRING, .z = name, .n = (uint32_t)strlen(name) };
+  SStrToken dbToken = { .type = TK_STRING, .z = name, .n = (uint32_t)strlen(name) };
   
   for (int32_t i = 0; i < num; ++i) {
     if (i >= 1) {
@@ -3712,7 +3713,7 @@ static int32_t setTableCondForSTableQuery(SSqlCmd* pCmd, SQueryInfo* pQueryInfo,
 
     char      idBuf[TSDB_TABLE_FNAME_LEN] = {0};
     int32_t   xlen = (int32_t)strlen(segments[i]);
-    SSQLToken t = {.z = segments[i], .n = xlen, .type = TK_STRING};
+    SStrToken t = {.z = segments[i], .n = xlen, .type = TK_STRING};
 
     int32_t ret = setObjFullName(idBuf, account, &dbToken, &t, &xlen);
     if (ret != TSDB_CODE_SUCCESS) {
@@ -4033,7 +4034,7 @@ int32_t getTimeRange(STimeWindow* win, tSQLExpr* pRight, int32_t optr, int16_t t
         return TSDB_CODE_TSC_INVALID_SQL;
       }
     } else {
-      SSQLToken token = {.z = pRight->val.pz, .n = pRight->val.nLen, .type = TK_ID};
+      SStrToken token = {.z = pRight->val.pz, .n = pRight->val.nLen, .type = TK_ID};
       int32_t   len = tSQLGetToken(pRight->val.pz, &token.type);
 
       if ((token.type != TK_INTEGER && token.type != TK_FLOAT) || len != pRight->val.nLen) {
@@ -4279,7 +4280,7 @@ int32_t parseOrderbyClause(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SQuerySQL* pQu
     return TSDB_CODE_SUCCESS;
   }
 
-  SSQLToken    columnName = {pVar->nLen, pVar->nType, pVar->pz};
+  SStrToken    columnName = {pVar->nLen, pVar->nType, pVar->pz};
   SColumnIndex index = {0};
 
   if (UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {  // super table query
@@ -4348,7 +4349,7 @@ int32_t parseOrderbyClause(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SQuerySQL* pQu
       }
 
       tVariant* pVar2 = &pSortorder->a[1].pVar;
-      SSQLToken cname = {pVar2->nLen, pVar2->nType, pVar2->pz};
+      SStrToken cname = {pVar2->nLen, pVar2->nType, pVar2->pz};
       if (getColumnIndexByName(pCmd, &cname, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
@@ -4477,7 +4478,7 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     }
 
     SColumnIndex index = COLUMN_INDEX_INITIALIZER;
-    SSQLToken    name = {.z = pItem->pVar.pz, .n = pItem->pVar.nLen, .type = TK_STRING};
+    SStrToken    name = {.z = pItem->pVar.pz, .n = pItem->pVar.nLen, .type = TK_STRING};
 
     if (getColumnIndexByName(pCmd, &name, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
       return TSDB_CODE_TSC_INVALID_SQL;
@@ -4515,12 +4516,12 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     SColumnIndex srcIndex = COLUMN_INDEX_INITIALIZER;
     SColumnIndex destIndex = COLUMN_INDEX_INITIALIZER;
 
-    SSQLToken srcToken = {.z = pSrcItem->pVar.pz, .n = pSrcItem->pVar.nLen, .type = TK_STRING};
+    SStrToken srcToken = {.z = pSrcItem->pVar.pz, .n = pSrcItem->pVar.nLen, .type = TK_STRING};
     if (getColumnIndexByName(pCmd, &srcToken, pQueryInfo, &srcIndex) != TSDB_CODE_SUCCESS) {
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg17);
     }
 
-    SSQLToken destToken = {.z = pDstItem->pVar.pz, .n = pDstItem->pVar.nLen, .type = TK_STRING};
+    SStrToken destToken = {.z = pDstItem->pVar.pz, .n = pDstItem->pVar.nLen, .type = TK_STRING};
     if (getColumnIndexByName(pCmd, &destToken, pQueryInfo, &destIndex) == TSDB_CODE_SUCCESS) {
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg19);
     }
@@ -4544,7 +4545,7 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     int16_t       numOfTags = tscGetNumOfTags(pTableMeta);
 
     SColumnIndex columnIndex = COLUMN_INDEX_INITIALIZER;
-    SSQLToken    name = {.type = TK_STRING, .z = pTagName->pz, .n = pTagName->nLen};
+    SStrToken    name = {.type = TK_STRING, .z = pTagName->pz, .n = pTagName->nLen};
     if (getColumnIndexByName(pCmd, &name, pQueryInfo, &columnIndex) != TSDB_CODE_SUCCESS) {
       return TSDB_CODE_TSC_INVALID_SQL;
     }
@@ -4637,7 +4638,7 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     tVariantListItem* pItem = &pAlterSQL->varList->a[0];
 
     SColumnIndex columnIndex = COLUMN_INDEX_INITIALIZER;
-    SSQLToken    name = {.type = TK_STRING, .z = pItem->pVar.pz, .n = pItem->pVar.nLen};
+    SStrToken    name = {.type = TK_STRING, .z = pItem->pVar.pz, .n = pItem->pVar.nLen};
     if (getColumnIndexByName(pCmd, &name, pQueryInfo, &columnIndex) != TSDB_CODE_SUCCESS) {
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg17);
     }
@@ -4757,7 +4758,7 @@ int32_t validateDNodeConfig(tDCLSQL* pOptions) {
       {"dDebugFlag", 10}, {"mqttDebugFlag", 13},    {"wDebugFlag", 10}, {"tmrDebugFlag", 12},
   };
 
-  SSQLToken* pOptionToken = &pOptions->a[1];
+  SStrToken* pOptionToken = &pOptions->a[1];
 
   if (pOptions->nTokens == 2) {
     // reset log and reset query cache does not need value
@@ -4769,7 +4770,7 @@ int32_t validateDNodeConfig(tDCLSQL* pOptions) {
     }
   } else if ((strncasecmp(cfgOptions[tokenBalance].name, pOptionToken->z, pOptionToken->n) == 0) &&
              (cfgOptions[tokenBalance].len == pOptionToken->n)) {
-    SSQLToken* pValToken = &pOptions->a[2];
+    SStrToken* pValToken = &pOptions->a[2];
     int32_t vnodeId = 0;
     int32_t dnodeId = 0;
     strdequote(pValToken->z);
@@ -4780,14 +4781,14 @@ int32_t validateDNodeConfig(tDCLSQL* pOptions) {
     return TSDB_CODE_SUCCESS;
   } else if ((strncasecmp(cfgOptions[tokenMonitor].name, pOptionToken->z, pOptionToken->n) == 0) &&
              (cfgOptions[tokenMonitor].len == pOptionToken->n)) {
-    SSQLToken* pValToken = &pOptions->a[2];
+    SStrToken* pValToken = &pOptions->a[2];
     int32_t    val = strtol(pValToken->z, NULL, 10);
     if (val != 0 && val != 1) {
       return TSDB_CODE_TSC_INVALID_SQL;  // options value is invalid
     }
     return TSDB_CODE_SUCCESS;
   } else {
-    SSQLToken* pValToken = &pOptions->a[2];
+    SStrToken* pValToken = &pOptions->a[2];
 
     int32_t val = strtol(pValToken->z, NULL, 10);
     if (val < 0 || val > 256) {
@@ -4816,7 +4817,7 @@ int32_t validateLocalConfig(tDCLSQL* pOptions) {
   SDNodeDynConfOption LOCAL_DYNAMIC_CFG_OPTIONS[6] = {{"resetLog", 8},    {"rpcDebugFlag", 12}, {"tmrDebugFlag", 12},
                                                       {"cDebugFlag", 10}, {"uDebugFlag", 10},   {"debugFlag", 9}};
 
-  SSQLToken* pOptionToken = &pOptions->a[0];
+  SStrToken* pOptionToken = &pOptions->a[0];
 
   if (pOptions->nTokens == 1) {
     // reset log does not need value
@@ -4827,7 +4828,7 @@ int32_t validateLocalConfig(tDCLSQL* pOptions) {
       }
     }
   } else {
-    SSQLToken* pValToken = &pOptions->a[1];
+    SStrToken* pValToken = &pOptions->a[1];
 
     int32_t val = strtol(pValToken->z, NULL, 10);
     if (val < 131 || val > 199) {
@@ -4852,7 +4853,7 @@ int32_t validateColumnName(char* name) {
     return TSDB_CODE_TSC_INVALID_SQL;
   }
 
-  SSQLToken token = {.z = name};
+  SStrToken token = {.z = name};
   token.n = tSQLGetToken(name, &token.type);
 
   if (token.type != TK_STRING && token.type != TK_ID) {
@@ -5031,7 +5032,7 @@ static int32_t setTimePrecision(SSqlCmd* pCmd, SCMCreateDbMsg* pMsg, SCreateDBIn
 
   pMsg->precision = TSDB_TIME_PRECISION_MILLI;  // millisecond by default
 
-  SSQLToken* pToken = &pCreateDbInfo->precision;
+  SStrToken* pToken = &pCreateDbInfo->precision;
   if (pToken->n > 0) {
     pToken->n = strdequote(pToken->z);
 
@@ -5702,7 +5703,7 @@ int32_t doCheckForCreateTable(SSqlObj* pSql, int32_t subClauseIndex, SSqlInfo* p
   assert(pFieldList != NULL);
 
   // if sql specifies db, use it, otherwise use default db
-  SSQLToken* pzTableName = &(pCreateTable->name);
+  SStrToken* pzTableName = &(pCreateTable->name);
 
   if (tscValidateName(pzTableName) != TSDB_CODE_SUCCESS) {
     return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
@@ -5757,7 +5758,7 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
   STableMetaInfo* pStableMeterMetaInfo = tscGetMetaInfo(pQueryInfo, STABLE_INDEX);
 
   // super table name, create table by using dst
-  SSQLToken* pToken = &(pCreateTable->usingInfo.stableName);
+  SStrToken* pToken = &(pCreateTable->usingInfo.stableName);
 
   if (tscValidateName(pToken) != TSDB_CODE_SUCCESS) {
     return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
@@ -5850,7 +5851,7 @@ int32_t doCheckForStream(SSqlObj* pSql, SSqlInfo* pInfo) {
   STableMetaInfo*  pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
 
   // if sql specifies db, use it, otherwise use default db
-  SSQLToken* pzTableName = &(pCreateTable->name);
+  SStrToken* pzTableName = &(pCreateTable->name);
   SQuerySQL* pQuerySql = pCreateTable->pSelect;
 
   if (tscValidateName(pzTableName) != TSDB_CODE_SUCCESS) {
@@ -5863,7 +5864,7 @@ int32_t doCheckForStream(SSqlObj* pSql, SSqlInfo* pInfo) {
   }
   
   tVariant* pVar = &pSrcMeterName->a[0].pVar;
-  SSQLToken srcToken = {.z = pVar->pz, .n = pVar->nLen, .type = TK_STRING};
+  SStrToken srcToken = {.z = pVar->pz, .n = pVar->nLen, .type = TK_STRING};
   if (tscValidateName(&srcToken) != TSDB_CODE_SUCCESS) {
     return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
@@ -6004,7 +6005,7 @@ int32_t doCheckForQuery(SSqlObj* pSql, SQuerySQL* pQuerySql, int32_t index) {
 
     pTableItem->nLen = strdequote(pTableItem->pz);
 
-    SSQLToken tableName = {.z = pTableItem->pz, .n = pTableItem->nLen, .type = TK_STRING};
+    SStrToken tableName = {.z = pTableItem->pz, .n = pTableItem->nLen, .type = TK_STRING};
     if (tscValidateName(&tableName) != TSDB_CODE_SUCCESS) {
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg0);
     }
@@ -6015,13 +6016,13 @@ int32_t doCheckForQuery(SSqlObj* pSql, SQuerySQL* pQuerySql, int32_t index) {
 
     STableMetaInfo* pTableMetaInfo1 = tscGetMetaInfo(pQueryInfo, i/2);
 
-    SSQLToken t = {.type = TSDB_DATA_TYPE_BINARY, .n = pTableItem->nLen, .z = pTableItem->pz};
+    SStrToken t = {.type = TSDB_DATA_TYPE_BINARY, .n = pTableItem->nLen, .z = pTableItem->pz};
     if (tscSetTableFullName(pTableMetaInfo1, &t, pSql) != TSDB_CODE_SUCCESS) {
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
 
     tVariant* pTableItem1 = &pQuerySql->from->a[i + 1].pVar;
-    SSQLToken aliasName = {.z = pTableItem1->pz, .n = pTableItem1->nLen, .type = TK_STRING};
+    SStrToken aliasName = {.z = pTableItem1->pz, .n = pTableItem1->nLen, .type = TK_STRING};
     if (tscValidateName(&aliasName) != TSDB_CODE_SUCCESS) {
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg11);
     }
@@ -6243,7 +6244,7 @@ int32_t exprTreeFromSqlExpr(SSqlCmd* pCmd, tExprNode **pExpr, const tSQLExpr* pS
     (*pExpr)->_node.pLeft = pLeft;
     (*pExpr)->_node.pRight = pRight;
     
-    SSQLToken t = {.type = pSqlExpr->nSQLOptr};
+    SStrToken t = {.type = pSqlExpr->nSQLOptr};
     (*pExpr)->_node.optr = getBinaryExprOptr(&t);
     
     assert((*pExpr)->_node.optr != 0);
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index b0c66a22cdafdecf001507ef66e800792dae8427..e33bfe44d19a9b90f20a39bf00a063ae435b0324 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -931,8 +931,8 @@ int32_t tscBuildAcctMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
   SCMCreateAcctMsg *pAlterMsg = (SCMCreateAcctMsg *)pCmd->payload;
 
-  SSQLToken *pName = &pInfo->pDCLInfo->user.user;
-  SSQLToken *pPwd = &pInfo->pDCLInfo->user.passwd;
+  SStrToken *pName = &pInfo->pDCLInfo->user.user;
+  SStrToken *pPwd = &pInfo->pDCLInfo->user.passwd;
 
   strncpy(pAlterMsg->user, pName->z, pName->n);
   strncpy(pAlterMsg->pass, pPwd->z, pPwd->n);
@@ -1134,13 +1134,13 @@ int32_t tscBuildShowMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   pShowMsg->type = pShowInfo->showType;
 
   if (pShowInfo->showType != TSDB_MGMT_TABLE_VNODES) {
-    SSQLToken *pPattern = &pShowInfo->pattern;
+    SStrToken *pPattern = &pShowInfo->pattern;
     if (pPattern->type > 0) {  // only show tables support wildcard query
       strncpy(pShowMsg->payload, pPattern->z, pPattern->n);
       pShowMsg->payloadLen = htons(pPattern->n);
     }
   } else {
-    SSQLToken *pEpAddr = &pShowInfo->prefix;
+    SStrToken *pEpAddr = &pShowInfo->prefix;
     assert(pEpAddr->n > 0 && pEpAddr->type > 0);
 
     strncpy(pShowMsg->payload, pEpAddr->z, pEpAddr->n);
diff --git a/src/client/src/tscSql.c b/src/client/src/tscSql.c
index 2906e5f4e250c28d4436612a6a028dd5bd5a41f6..1a774e878494e8055bf81b1b22a8510dd79003b2 100644
--- a/src/client/src/tscSql.c
+++ b/src/client/src/tscSql.c
@@ -855,7 +855,7 @@ static int tscParseTblNameList(SSqlObj *pSql, const char *tblNameList, int32_t t
     str = nextStr + 1;
     len = (int32_t)strtrim(tblName);
 
-    SSQLToken sToken = {.n = len, .type = TK_ID, .z = tblName};
+    SStrToken sToken = {.n = len, .type = TK_ID, .z = tblName};
     tSQLGetToken(tblName, &sToken.type);
 
     // Check if the table name available or not
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index d8f030938e9c32578ce576dc72f2db1bdc0620f6..788283a1adcc74ed6c7101464b500b2580eb3090 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -744,7 +744,7 @@ bool tscIsInsertData(char* sqlstr) {
   int32_t index = 0;
 
   do {
-    SSQLToken t0 = tStrGetToken(sqlstr, &index, false, 0, NULL);
+    SStrToken t0 = tStrGetToken(sqlstr, &index, false, 0, NULL);
     if (t0.type != TK_LP) {
       return t0.type == TK_INSERT || t0.type == TK_IMPORT;
     }
@@ -1187,7 +1187,7 @@ void tscColumnListDestroy(SArray* pColumnList) {
  * 'first_part.second_part'
  *
  */
-static int32_t validateQuoteToken(SSQLToken* pToken) {
+static int32_t validateQuoteToken(SStrToken* pToken) {
   strdequote(pToken->z);
   pToken->n = (uint32_t)strtrim(pToken->z);
 
@@ -1203,7 +1203,7 @@ static int32_t validateQuoteToken(SSQLToken* pToken) {
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t tscValidateName(SSQLToken* pToken) {
+int32_t tscValidateName(SStrToken* pToken) {
   if (pToken->type != TK_STRING && pToken->type != TK_ID) {
     return TSDB_CODE_TSC_INVALID_SQL;
   }
diff --git a/src/common/inc/tname.h b/src/common/inc/tname.h
index 65f3d8c3f9b57960185cd4f8e3ab9739e3aa59d2..2a4ac3fc40d043ead8262b8b32b24287d88f09f1 100644
--- a/src/common/inc/tname.h
+++ b/src/common/inc/tname.h
@@ -25,11 +25,11 @@ void extractTableName(const char *tableId, char *name);
 
 char* extractDBName(const char *tableId, char *name);
 
-void extractTableNameFromToken(SSQLToken *pToken, SSQLToken* pTable);
+void extractTableNameFromToken(SStrToken *pToken, SStrToken* pTable);
 
 SSchema tGetTableNameColumnSchema();
 
-SSchema tGetUserSpecifiedColumnSchema(tVariant* pVal, const char* name);
+SSchema tGetUserSpecifiedColumnSchema(tVariant* pVal, SStrToken* exprStr, const char* name);
 
 bool tscValidateTableNameLength(size_t len);
 
diff --git a/src/common/inc/tvariant.h b/src/common/inc/tvariant.h
index 211635b4af2f19397a36ecef825e9e762f7398ba..e9973bcb9595c5ace0b4cb20f2d8776a5cf05501 100644
--- a/src/common/inc/tvariant.h
+++ b/src/common/inc/tvariant.h
@@ -36,7 +36,7 @@ typedef struct tVariant {
   };
 } tVariant;
 
-void tVariantCreate(tVariant *pVar, SSQLToken *token);
+void tVariantCreate(tVariant *pVar, SStrToken *token);
 
 void tVariantCreateFromString(tVariant *pVar, char *pz, uint32_t len, uint32_t type);
 
diff --git a/src/common/src/tname.c b/src/common/src/tname.c
index e59d20b9ce97325fa4a960bf9060753bb8b56c8c..2eda5953a3e5c9e83a5986de71baf173579cb890 100644
--- a/src/common/src/tname.c
+++ b/src/common/src/tname.c
@@ -48,7 +48,7 @@ SSchema tGetTableNameColumnSchema() {
   return s;
 }
 
-SSchema tGetUserSpecifiedColumnSchema(tVariant* pVal, const char* name) {
+SSchema tGetUserSpecifiedColumnSchema(tVariant* pVal, SStrToken* exprStr, const char* name) {
   SSchema s = {0};
 
   s.type  = pVal->nType;
@@ -62,8 +62,8 @@ SSchema tGetUserSpecifiedColumnSchema(tVariant* pVal, const char* name) {
   if (name != NULL) {
     tstrncpy(s.name, name, sizeof(s.name));
   } else {
-    tVariantToString(pVal, s.name);
-    strdequote(s.name);
+    size_t len = MIN(sizeof(s.name), exprStr->n + 1);
+    tstrncpy(s.name, exprStr->z, len);
   }
 
   return s;
@@ -132,7 +132,7 @@ int64_t taosGetIntervalStartTimestamp(int64_t startTime, int64_t slidingTime, in
  * tablePrefix.columnName
  * extract table name and save it in pTable, with only column name in pToken
  */
-void extractTableNameFromToken(SSQLToken* pToken, SSQLToken* pTable) {
+void extractTableNameFromToken(SStrToken* pToken, SStrToken* pTable) {
   const char sep = TS_PATH_DELIMITER[0];
 
   if (pToken == pTable || pToken == NULL || pTable == NULL) {
diff --git a/src/common/src/tvariant.c b/src/common/src/tvariant.c
index 6e8111aa725ecf83e52ceaecf3336d7c611ce73c..4036e578b42edf271fce8d41ab8f9e8579b75c56 100644
--- a/src/common/src/tvariant.c
+++ b/src/common/src/tvariant.c
@@ -23,7 +23,7 @@
 #include "tutil.h"
 
 // todo support scientific expression number and oct number
-void tVariantCreate(tVariant *pVar, SSQLToken *token) { tVariantCreateFromString(pVar, token->z, token->n, token->type); }
+void tVariantCreate(tVariant *pVar, SStrToken *token) { tVariantCreateFromString(pVar, token->z, token->n, token->type); }
 
 void tVariantCreateFromString(tVariant *pVar, char *pz, uint32_t len, uint32_t type) {
   memset(pVar, 0, sizeof(tVariant));
@@ -270,7 +270,7 @@ static int32_t doConvertToInteger(tVariant *pVariant, char *pDest, int32_t type,
     errno = 0;
     char *endPtr = NULL;
 
-    SSQLToken token = {0};
+    SStrToken token = {0};
     token.n = tSQLGetToken(pVariant->pz, &token.type);
 
     if (token.type == TK_MINUS || token.type == TK_PLUS) {
@@ -319,7 +319,7 @@ static int32_t doConvertToInteger(tVariant *pVariant, char *pDest, int32_t type,
     errno = 0;
     wchar_t *endPtr = NULL;
 
-    SSQLToken token = {0};
+    SStrToken token = {0};
     token.n = tSQLGetToken(pVariant->pz, &token.type);
 
     if (token.type == TK_MINUS || token.type == TK_PLUS) {
@@ -478,7 +478,7 @@ static int32_t toNchar(tVariant *pVariant, char **pDest, int32_t *pDestSize) {
 }
 
 static FORCE_INLINE int32_t convertToDouble(char *pStr, int32_t len, double *value) {
-  SSQLToken stoken = {.z = pStr, .n = len};
+  SStrToken stoken = {.z = pStr, .n = len};
   
   if (TK_ILLEGAL == isValidNumber(&stoken)) {
     return -1;
@@ -504,7 +504,7 @@ static FORCE_INLINE int32_t convertToInteger(tVariant *pVariant, int64_t *result
     errno = 0;
     char *endPtr = NULL;
     
-    SSQLToken token = {0};
+    SStrToken token = {0};
     token.n = tSQLGetToken(pVariant->pz, &token.type);
     
     if (token.type == TK_MINUS || token.type == TK_PLUS) {
@@ -521,7 +521,7 @@ static FORCE_INLINE int32_t convertToInteger(tVariant *pVariant, int64_t *result
       return 0;
     }
     
-    SSQLToken sToken = {.z = pVariant->pz, .n = pVariant->nLen};
+    SStrToken sToken = {.z = pVariant->pz, .n = pVariant->nLen};
     if (TK_ILLEGAL == isValidNumber(&sToken)) {
       return -1;
     }
@@ -557,7 +557,7 @@ static FORCE_INLINE int32_t convertToInteger(tVariant *pVariant, int64_t *result
     errno = 0;
     wchar_t *endPtr = NULL;
     
-    SSQLToken token = {0};
+    SStrToken token = {0};
     token.n = tSQLGetToken(pVariant->pz, &token.type);
     
     if (token.type == TK_MINUS || token.type == TK_PLUS) {
diff --git a/src/query/inc/qAst.h b/src/query/inc/qAst.h
index ec568a6cdb1fa85547128608059d0bacff1e41de..547616dee6794b76c1faa3df7981db04c8613e29 100644
--- a/src/query/inc/qAst.h
+++ b/src/query/inc/qAst.h
@@ -80,7 +80,7 @@ void tExprTreeTraverse(tExprNode *pExpr, SSkipList *pSkipList, SArray *result, S
 void tExprTreeCalcTraverse(tExprNode *pExprs, int32_t numOfRows, char *pOutput, void *param, int32_t order,
                                 char *(*cb)(void *, const char*, int32_t));
 
-uint8_t getBinaryExprOptr(SSQLToken *pToken);
+uint8_t getBinaryExprOptr(SStrToken *pToken);
 
 void tExprNodeDestroy(tExprNode *pNode, void (*fp)(void *));
 void exprTreeToBinary(SBufferWriter* bw, tExprNode* pExprTree);
diff --git a/src/query/inc/qSqlparser.h b/src/query/inc/qSqlparser.h
index 2cfee344aaf8e995efd829e382c644f52b63186c..69fc0bc7ef2e1f9fd661f32adfcf44e4d9c7f59a 100644
--- a/src/query/inc/qSqlparser.h
+++ b/src/query/inc/qSqlparser.h
@@ -26,7 +26,7 @@ extern "C" {
 #include "tstoken.h"
 #include "tvariant.h"
 
-#define ParseTOKENTYPE SSQLToken
+#define ParseTOKENTYPE SStrToken
 extern char tTokenTypeSwitcher[13];
 
 #define toTSDBType(x)                          \
@@ -71,16 +71,16 @@ typedef struct SQuerySQL {
   struct tSQLExpr *    pWhere;       // where clause [optional]
   tVariantList *       pGroupby;     // groupby clause, only for tags[optional]
   tVariantList *       pSortOrder;   // orderby [optional]
-  SSQLToken            interval;     // interval [optional]
-  SSQLToken            sliding;      // sliding window [optional]
+  SStrToken            interval;     // interval [optional]
+  SStrToken            sliding;      // sliding window [optional]
   SLimitVal            limit;        // limit offset [optional]
   SLimitVal            slimit;       // group limit offset [optional]
   tVariantList *       fillType;     // fill type[optional]
-  SSQLToken            selectToken;  // sql string
+  SStrToken            selectToken;  // sql string
 } SQuerySQL;
 
 typedef struct SCreateTableSQL {
-  struct SSQLToken name;  // meter name, create table [meterName] xxx
+  struct SStrToken name;  // meter name, create table [meterName] xxx
   bool             existCheck;
   
   int8_t           type; // create normal table/from super table/ stream
@@ -90,7 +90,7 @@ typedef struct SCreateTableSQL {
   } colInfo;
   
   struct {
-    SSQLToken     stableName;  // super table name, for using clause
+    SStrToken     stableName;  // super table name, for using clause
     tVariantList *pTagVals;    // create by using metric, tag value
     STagData      tagdata;
   } usingInfo;
@@ -99,7 +99,7 @@ typedef struct SCreateTableSQL {
 } SCreateTableSQL;
 
 typedef struct SAlterTableSQL {
-  SSQLToken     name;
+  SStrToken     name;
   int16_t       type;
   STagData      tagData;
   
@@ -108,7 +108,7 @@ typedef struct SAlterTableSQL {
 } SAlterTableSQL;
 
 typedef struct SCreateDBInfo {
-  SSQLToken dbname;
+  SStrToken dbname;
   int32_t   replica;
   int32_t   cacheBlockSize;
   int32_t   maxTablesPerVnode;
@@ -121,7 +121,7 @@ typedef struct SCreateDBInfo {
   int32_t   walLevel;
   int32_t   quorum;
   int32_t   compressionLevel;
-  SSQLToken precision;
+  SStrToken precision;
   bool      ignoreExists;
   
   tVariantList *keep;
@@ -136,33 +136,33 @@ typedef struct SCreateAcctSQL {
   int64_t   maxStorage;
   int64_t   maxQueryTime;
   int32_t   maxConnections;
-  SSQLToken stat;
+  SStrToken stat;
 } SCreateAcctSQL;
 
 typedef struct SShowInfo {
   uint8_t showType;
-  SSQLToken prefix;
-  SSQLToken pattern;
+  SStrToken prefix;
+  SStrToken pattern;
 } SShowInfo;
 
 typedef struct SUserInfo {
-  SSQLToken user;
-  SSQLToken passwd;
-  SSQLToken privilege;
+  SStrToken user;
+  SStrToken passwd;
+  SStrToken privilege;
   int16_t   type;
 } SUserInfo;
 
 typedef struct tDCLSQL {
   int32_t    nTokens; /* Number of expressions on the list */
   int32_t    nAlloc;  /* Number of entries allocated below */
-  SSQLToken *a;       /* one entry for element */
+  SStrToken *a;       /* one entry for element */
   bool  existsCheck;
   
   union {
     SCreateDBInfo  dbOpt;
     SCreateAcctSQL acctOpt;
     SShowInfo      showOpt;
-    SSQLToken ip;
+    SStrToken ip;
   };
   
   SUserInfo user;
@@ -194,14 +194,14 @@ typedef struct tSQLExpr {
   
   // the full sql string of function(col, param), which is actually the raw
   // field name, since the function name is kept in nSQLOptr already
-  SSQLToken operand;
-  SSQLToken colInfo;            // field id
+  SStrToken operand;
+  SStrToken colInfo;            // field id
   tVariant  val;                // value only for string, float, int
   
   struct tSQLExpr *pLeft;       // left child
   struct tSQLExpr *pRight;      // right child
-  
   struct tSQLExprList *pParam;  // function parameters
+  SStrToken token;              // original sql expr string
 } tSQLExpr;
 
 // used in select clause. select <tSQLExprList> from xxx
@@ -243,7 +243,7 @@ tVariantList *tVariantListAppend(tVariantList *pList, tVariant *pVar, uint8_t so
 
 tVariantList *tVariantListInsert(tVariantList *pList, tVariant *pVar, uint8_t sortOrder, int32_t index);
 
-tVariantList *tVariantListAppendToken(tVariantList *pList, SSQLToken *pAliasToken, uint8_t sortOrder);
+tVariantList *tVariantListAppendToken(tVariantList *pList, SStrToken *pAliasToken, uint8_t sortOrder);
 void          tVariantListDestroy(tVariantList *pList);
 
 tFieldList *tFieldListAppend(tFieldList *pList, TAOS_FIELD *pField);
@@ -254,61 +254,61 @@ tSQLExpr *tSQLExprCreate(tSQLExpr *pLeft, tSQLExpr *pRight, int32_t optType);
 
 void tSQLExprDestroy(tSQLExpr *);
 
-tSQLExprList *tSQLExprListAppend(tSQLExprList *pList, tSQLExpr *pNode, SSQLToken *pToken);
+tSQLExprList *tSQLExprListAppend(tSQLExprList *pList, tSQLExpr *pNode, SStrToken *pToken);
 
 void tSQLExprListDestroy(tSQLExprList *pList);
 
-SQuerySQL *tSetQuerySQLElems(SSQLToken *pSelectToken, tSQLExprList *pSelection, tVariantList *pFrom, tSQLExpr *pWhere,
-                             tVariantList *pGroupby, tVariantList *pSortOrder, SSQLToken *pInterval,
-                             SSQLToken *pSliding, tVariantList *pFill, SLimitVal *pLimit, SLimitVal *pGLimit);
+SQuerySQL *tSetQuerySQLElems(SStrToken *pSelectToken, tSQLExprList *pSelection, tVariantList *pFrom, tSQLExpr *pWhere,
+                             tVariantList *pGroupby, tVariantList *pSortOrder, SStrToken *pInterval,
+                             SStrToken *pSliding, tVariantList *pFill, SLimitVal *pLimit, SLimitVal *pGLimit);
 
-SCreateTableSQL *tSetCreateSQLElems(tFieldList *pCols, tFieldList *pTags, SSQLToken *pMetricName,
+SCreateTableSQL *tSetCreateSQLElems(tFieldList *pCols, tFieldList *pTags, SStrToken *pMetricName,
                                     tVariantList *pTagVals, SQuerySQL *pSelect, int32_t type);
 
 void      tSQLExprNodeDestroy(tSQLExpr *pExpr);
 tSQLExpr *tSQLExprNodeClone(tSQLExpr *pExpr);
 
-SAlterTableSQL *tAlterTableSQLElems(SSQLToken *pMeterName, tFieldList *pCols, tVariantList *pVals, int32_t type);
+SAlterTableSQL *tAlterTableSQLElems(SStrToken *pMeterName, tFieldList *pCols, tVariantList *pVals, int32_t type);
 
 tSQLExprListList *tSQLListListAppend(tSQLExprListList *pList, tSQLExprList *pExprList);
 
 void destroyAllSelectClause(SSubclauseInfo *pSql);
 void doDestroyQuerySql(SQuerySQL *pSql);
 
-SSqlInfo *      setSQLInfo(SSqlInfo *pInfo, void *pSqlExprInfo, SSQLToken *pMeterName, int32_t type);
+SSqlInfo *      setSQLInfo(SSqlInfo *pInfo, void *pSqlExprInfo, SStrToken *pMeterName, int32_t type);
 SSubclauseInfo *setSubclause(SSubclauseInfo *pClause, void *pSqlExprInfo);
 
 SSubclauseInfo *appendSelectClause(SSubclauseInfo *pInfo, void *pSubclause);
 
-void setCreatedTableName(SSqlInfo *pInfo, SSQLToken *pMeterName, SSQLToken *pIfNotExists);
+void setCreatedTableName(SSqlInfo *pInfo, SStrToken *pMeterName, SStrToken *pIfNotExists);
 
 void SQLInfoDestroy(SSqlInfo *pInfo);
 
 void setDCLSQLElems(SSqlInfo *pInfo, int32_t type, int32_t nParams, ...);
-void setDropDBTableInfo(SSqlInfo *pInfo, int32_t type, SSQLToken* pToken, SSQLToken* existsCheck);
-void setShowOptions(SSqlInfo *pInfo, int32_t type, SSQLToken* prefix, SSQLToken* pPatterns);
+void setDropDBTableInfo(SSqlInfo *pInfo, int32_t type, SStrToken* pToken, SStrToken* existsCheck);
+void setShowOptions(SSqlInfo *pInfo, int32_t type, SStrToken* prefix, SStrToken* pPatterns);
 
-tDCLSQL *tTokenListAppend(tDCLSQL *pTokenList, SSQLToken *pToken);
+tDCLSQL *tTokenListAppend(tDCLSQL *pTokenList, SStrToken *pToken);
 
-void setCreateDBSQL(SSqlInfo *pInfo, int32_t type, SSQLToken *pToken, SCreateDBInfo *pDB, SSQLToken *pIgExists);
+void setCreateDBSQL(SSqlInfo *pInfo, int32_t type, SStrToken *pToken, SCreateDBInfo *pDB, SStrToken *pIgExists);
 
-void setCreateAcctSQL(SSqlInfo *pInfo, int32_t type, SSQLToken *pName, SSQLToken *pPwd, SCreateAcctSQL *pAcctInfo);
-void setCreateUserSQL(SSqlInfo *pInfo, SSQLToken *pName, SSQLToken *pPasswd);
-void setKillSQL(SSqlInfo *pInfo, int32_t type, SSQLToken *ip);
-void setAlterUserSQL(SSqlInfo *pInfo, int16_t type, SSQLToken *pName, SSQLToken* pPwd, SSQLToken *pPrivilege);
+void setCreateAcctSQL(SSqlInfo *pInfo, int32_t type, SStrToken *pName, SStrToken *pPwd, SCreateAcctSQL *pAcctInfo);
+void setCreateUserSQL(SSqlInfo *pInfo, SStrToken *pName, SStrToken *pPasswd);
+void setKillSQL(SSqlInfo *pInfo, int32_t type, SStrToken *ip);
+void setAlterUserSQL(SSqlInfo *pInfo, int16_t type, SStrToken *pName, SStrToken* pPwd, SStrToken *pPrivilege);
 
 void setDefaultCreateDbOption(SCreateDBInfo *pDBInfo);
 
 // prefix show db.tables;
-void setDBName(SSQLToken *pCpxName, SSQLToken *pDB);
+void setDBName(SStrToken *pCpxName, SStrToken *pDB);
 
-tSQLExpr *tSQLExprIdValueCreate(SSQLToken *pToken, int32_t optType);
+tSQLExpr *tSQLExprIdValueCreate(SStrToken *pToken, int32_t optType);
 
-tSQLExpr *tSQLExprCreateFunction(tSQLExprList *pList, SSQLToken *pFuncToken, SSQLToken *endToken, int32_t optType);
+tSQLExpr *tSQLExprCreateFunction(tSQLExprList *pList, SStrToken *pFuncToken, SStrToken *endToken, int32_t optType);
 
-void tSQLSetColumnInfo(TAOS_FIELD *pField, SSQLToken *pName, TAOS_FIELD *pType);
+void tSQLSetColumnInfo(TAOS_FIELD *pField, SStrToken *pName, TAOS_FIELD *pType);
 
-void tSQLSetColumnType(TAOS_FIELD *pField, SSQLToken *pToken);
+void tSQLSetColumnType(TAOS_FIELD *pField, SStrToken *pToken);
 
 void *ParseAlloc(void *(*mallocProc)(size_t));
 
diff --git a/src/query/inc/sql.y b/src/query/inc/sql.y
index edf59327abeee0437af82a29ab048a134b5edb22..7500dcba5667b83613a8b9ff035dff3a7b7574be 100644
--- a/src/query/inc/sql.y
+++ b/src/query/inc/sql.y
@@ -2,8 +2,8 @@
 //usage: lemon sql.y
 %token_prefix TK_
 
-%token_type {SSQLToken}
-%default_type {SSQLToken}
+%token_type {SStrToken}
+%default_type {SStrToken}
 %extra_argument {SSqlInfo* pInfo}
 
 %fallback ID BOOL TINYINT SMALLINT INTEGER BIGINT FLOAT DOUBLE STRING TIMESTAMP BINARY NCHAR.
@@ -80,11 +80,11 @@ cmd ::= SHOW GRANTS.     { setShowOptions(pInfo, TSDB_MGMT_TABLE_GRANTS, 0, 0);
 cmd ::= SHOW VNODES.                { setShowOptions(pInfo, TSDB_MGMT_TABLE_VNODES, 0, 0); }
 cmd ::= SHOW VNODES IPTOKEN(X).     { setShowOptions(pInfo, TSDB_MGMT_TABLE_VNODES, &X, 0); }
 
-%type dbPrefix {SSQLToken}
+%type dbPrefix {SStrToken}
 dbPrefix(A) ::=.                   {A.n = 0; A.type = 0;}
 dbPrefix(A) ::= ids(X) DOT.        {A = X;  }
 
-%type cpxName {SSQLToken}
+%type cpxName {SStrToken}
 cpxName(A) ::= .             {A.n = 0;  }
 cpxName(A) ::= DOT ids(Y).   {A = Y; A.n += 1;    }
 
@@ -101,19 +101,19 @@ cmd ::= SHOW dbPrefix(X) STABLES.      {
 }
 
 cmd ::= SHOW dbPrefix(X) STABLES LIKE ids(Y).      {
-    SSQLToken token;
+    SStrToken token;
     setDBName(&token, &X);
     setShowOptions(pInfo, TSDB_MGMT_TABLE_METRIC, &token, &Y);
 }
 
 cmd ::= SHOW dbPrefix(X) VGROUPS.    {
-    SSQLToken token;
+    SStrToken token;
     setDBName(&token, &X);
     setShowOptions(pInfo, TSDB_MGMT_TABLE_VGROUP, &token, 0);
 }
 
 cmd ::= SHOW dbPrefix(X) VGROUPS ids(Y).    {
-    SSQLToken token;
+    SStrToken token;
     setDBName(&token, &X);    
     setShowOptions(pInfo, TSDB_MGMT_TABLE_VGROUP, &token, &Y);
 }
@@ -145,7 +145,7 @@ cmd ::= ALTER DNODE ids(X) ids(Y).              { setDCLSQLElems(pInfo, TSDB_SQL
 cmd ::= ALTER DNODE ids(X) ids(Y) ids(Z).       { setDCLSQLElems(pInfo, TSDB_SQL_CFG_DNODE, 3, &X, &Y, &Z);      }
 cmd ::= ALTER LOCAL ids(X).                     { setDCLSQLElems(pInfo, TSDB_SQL_CFG_LOCAL, 1, &X);              }
 cmd ::= ALTER LOCAL ids(X) ids(Y).              { setDCLSQLElems(pInfo, TSDB_SQL_CFG_LOCAL, 2, &X, &Y);          }
-cmd ::= ALTER DATABASE ids(X) alter_db_optr(Y). { SSQLToken t = {0};  setCreateDBSQL(pInfo, TSDB_SQL_ALTER_DB, &X, &Y, &t);}
+cmd ::= ALTER DATABASE ids(X) alter_db_optr(Y). { SStrToken t = {0};  setCreateDBSQL(pInfo, TSDB_SQL_ALTER_DB, &X, &Y, &t);}
 
 cmd ::= ALTER ACCOUNT ids(X) acct_optr(Z).      { setCreateAcctSQL(pInfo, TSDB_SQL_ALTER_ACCT, &X, NULL, &Z);}
 cmd ::= ALTER ACCOUNT ids(X) PASS ids(Y) acct_optr(Z).      { setCreateAcctSQL(pInfo, TSDB_SQL_ALTER_ACCT, &X, &Y, &Z);}
@@ -153,15 +153,15 @@ cmd ::= ALTER ACCOUNT ids(X) PASS ids(Y) acct_optr(Z).      { setCreateAcctSQL(p
 // An IDENTIFIER can be a generic identifier, or one of several keywords.
 // Any non-standard keyword can also be an identifier.
 // And "ids" is an identifer-or-string.
-%type ids {SSQLToken}
+%type ids {SStrToken}
 ids(A) ::= ID(X).        {A = X; }
 ids(A) ::= STRING(X).    {A = X; }
 
-%type ifexists {SSQLToken}
+%type ifexists {SStrToken}
 ifexists(X) ::= IF EXISTS.          {X.n = 1;}
 ifexists(X) ::= .                   {X.n = 0;}
 
-%type ifnotexists {SSQLToken}
+%type ifnotexists {SStrToken}
 ifnotexists(X) ::= IF NOT EXISTS.   {X.n = 1;}
 ifnotexists(X) ::= .                {X.n = 0;}
 
@@ -416,7 +416,7 @@ selcollist(A) ::= sclp(P) STAR. {
 // An option "AS <id>" phrase that can follow one of the expressions that
 // define the result set, or one of the tables in the FROM clause.
 //
-%type as {SSQLToken}
+%type as {SStrToken}
 as(X) ::= AS ids(Y).    { X = Y;    }
 as(X) ::= ids(Y).       { X = Y;    }
 as(X) ::= .             { X.n = 0;  }
@@ -458,10 +458,10 @@ tablelist(A) ::= tablelist(Y) COMMA ids(X) cpxName(Z) ids(F). {
 }
 
 // The value of interval should be the form of "number+[a,s,m,h,d,n,y]" or "now"
-%type tmvar {SSQLToken}
+%type tmvar {SStrToken}
 tmvar(A) ::= VARIABLE(X).   {A = X;}
 
-%type interval_opt {SSQLToken}
+%type interval_opt {SStrToken}
 interval_opt(N) ::= INTERVAL LP tmvar(E) RP.    {N = E;     }
 interval_opt(N) ::= .                           {N.n = 0; N.z = NULL; N.type = 0;   }
 
@@ -482,7 +482,7 @@ fill_opt(N) ::= FILL LP ID(Y) RP.               {
     N = tVariantListAppendToken(NULL, &Y, -1);
 }
 
-%type sliding_opt {SSQLToken}
+%type sliding_opt {SStrToken}
 sliding_opt(K) ::= SLIDING LP tmvar(E) RP.      {K = E;     }
 sliding_opt(K) ::= .                            {K.n = 0; K.z = NULL; K.type = 0;   }
 
diff --git a/src/query/src/qAst.c b/src/query/src/qAst.c
index afa3618a96df6fd315a5fca7e5652497a13ea464..634f014d975430c8da3e4de406ef7c92482930b6 100644
--- a/src/query/src/qAst.c
+++ b/src/query/src/qAst.c
@@ -44,7 +44,7 @@
  * ver 0.3, pipeline filter in the form of: (a+2)/9 > 14
  *
  */
-static tExprNode *tExprNodeCreate(SSchema *pSchema, int32_t numOfCols, SSQLToken *pToken);
+static tExprNode *tExprNodeCreate(SSchema *pSchema, int32_t numOfCols, SStrToken *pToken);
 
 static tExprNode *createSyntaxTree(SSchema *pSchema, int32_t numOfCols, char *str, int32_t *i);
 static void       destroySyntaxTree(tExprNode *);
@@ -103,7 +103,7 @@ static void reviseBinaryExprIfNecessary(tExprNode **pLeft, tExprNode **pRight, u
   }
 }
 
-static tExprNode *tExprNodeCreate(SSchema *pSchema, int32_t numOfCols, SSQLToken *pToken) {
+static tExprNode *tExprNodeCreate(SSchema *pSchema, int32_t numOfCols, SStrToken *pToken) {
   /* if the token is not a value, return false */
   if (pToken->type == TK_RP || (pToken->type != TK_INTEGER && pToken->type != TK_FLOAT && pToken->type != TK_ID &&
                                 pToken->type != TK_TBNAME && pToken->type != TK_STRING && pToken->type != TK_BOOL)) {
@@ -117,7 +117,7 @@ static tExprNode *tExprNodeCreate(SSchema *pSchema, int32_t numOfCols, SSQLToken
     int32_t i = 0;
     if (pToken->type == TK_ID) {
       do {
-        SSQLToken tableToken = {0};
+        SStrToken tableToken = {0};
         extractTableNameFromToken(pToken, &tableToken);
 
         size_t len = strlen(pSchema[i].name);
@@ -157,7 +157,7 @@ static tExprNode *tExprNodeCreate(SSchema *pSchema, int32_t numOfCols, SSQLToken
   return pNode;
 }
 
-uint8_t getBinaryExprOptr(SSQLToken *pToken) {
+uint8_t getBinaryExprOptr(SStrToken *pToken) {
   switch (pToken->type) {
     case TK_LT:
       return TSDB_RELATION_LESS;
@@ -234,7 +234,7 @@ uint8_t isQueryOnPrimaryKey(const char *primaryColumnName, const tExprNode *pLef
 }
 
 static tExprNode *createSyntaxTree(SSchema *pSchema, int32_t numOfCols, char *str, int32_t *i) {
-  SSQLToken t0 = tStrGetToken(str, i, false, 0, NULL);
+  SStrToken t0 = tStrGetToken(str, i, false, 0, NULL);
   if (t0.n == 0) {
     return NULL;
   }
diff --git a/src/query/src/qParserImpl.c b/src/query/src/qParserImpl.c
index 0537726ad569427a89626e7bd6f81e6e942073ff..0b5408f793f7f6d3de06f53dd81bcca08d8fe8a8 100644
--- a/src/query/src/qParserImpl.c
+++ b/src/query/src/qParserImpl.c
@@ -33,7 +33,7 @@ SSqlInfo qSQLParse(const char *pStr) {
 
   int32_t i = 0;
   while (1) {
-    SSQLToken t0 = {0};
+    SStrToken t0 = {0};
 
     if (pStr[i] == 0) {
       Parse(pParser, 0, t0, &sqlInfo);
@@ -73,7 +73,7 @@ abort_parse:
   return sqlInfo;
 }
 
-tSQLExprList *tSQLExprListAppend(tSQLExprList *pList, tSQLExpr *pNode, SSQLToken *pToken) {
+tSQLExprList *tSQLExprListAppend(tSQLExprList *pList, tSQLExpr *pNode, SStrToken *pToken) {
   if (pList == NULL) {
     pList = calloc(1, sizeof(tSQLExprList));
   }
@@ -117,41 +117,45 @@ void tSQLExprListDestroy(tSQLExprList *pList) {
   free(pList);
 }
 
-tSQLExpr *tSQLExprIdValueCreate(SSQLToken *pAliasToken, int32_t optrType) {
-  tSQLExpr *nodePtr = calloc(1, sizeof(tSQLExpr));
+tSQLExpr *tSQLExprIdValueCreate(SStrToken *pToken, int32_t optrType) {
+  tSQLExpr *pSQLExpr = calloc(1, sizeof(tSQLExpr));
+
+  if (pToken != NULL) {
+    pSQLExpr->token = *pToken;
+  }
 
   if (optrType == TK_INTEGER || optrType == TK_STRING || optrType == TK_FLOAT || optrType == TK_BOOL) {
-    toTSDBType(pAliasToken->type);
+    toTSDBType(pToken->type);
 
-    tVariantCreate(&nodePtr->val, pAliasToken);
-    nodePtr->nSQLOptr = optrType;
+    tVariantCreate(&pSQLExpr->val, pToken);
+    pSQLExpr->nSQLOptr = optrType;
   } else if (optrType == TK_NOW) {
     // default use microsecond
-    nodePtr->val.i64Key = taosGetTimestamp(TSDB_TIME_PRECISION_MICRO);
-    nodePtr->val.nType = TSDB_DATA_TYPE_BIGINT;
-    nodePtr->nSQLOptr = TK_TIMESTAMP;  // TK_TIMESTAMP used to denote the time value is in microsecond
+    pSQLExpr->val.i64Key = taosGetTimestamp(TSDB_TIME_PRECISION_MICRO);
+    pSQLExpr->val.nType = TSDB_DATA_TYPE_BIGINT;
+    pSQLExpr->nSQLOptr = TK_TIMESTAMP;  // TK_TIMESTAMP used to denote the time value is in microsecond
   } else if (optrType == TK_VARIABLE) {
-    int32_t ret = getTimestampInUsFromStr(pAliasToken->z, pAliasToken->n, &nodePtr->val.i64Key);
+    int32_t ret = getTimestampInUsFromStr(pToken->z, pToken->n, &pSQLExpr->val.i64Key);
     UNUSED(ret);
 
-    nodePtr->val.nType = TSDB_DATA_TYPE_BIGINT;
-    nodePtr->nSQLOptr = TK_TIMESTAMP;
+    pSQLExpr->val.nType = TSDB_DATA_TYPE_BIGINT;
+    pSQLExpr->nSQLOptr = TK_TIMESTAMP;
   } else {  // it must be the column name (tk_id) if it is not the number
     assert(optrType == TK_ID || optrType == TK_ALL);
-    if (pAliasToken != NULL) {
-      nodePtr->colInfo = *pAliasToken;
+    if (pToken != NULL) {
+      pSQLExpr->colInfo = *pToken;
     }
 
-    nodePtr->nSQLOptr = optrType;
+    pSQLExpr->nSQLOptr = optrType;
   }
-  return nodePtr;
+  return pSQLExpr;
 }
 
 /*
  * pList is the parameters for function with id(optType)
  * function name is denoted by pFunctionToken
  */
-tSQLExpr *tSQLExprCreateFunction(tSQLExprList *pList, SSQLToken *pFuncToken, SSQLToken *endToken, int32_t optType) {
+tSQLExpr *tSQLExprCreateFunction(tSQLExprList *pList, SStrToken *pFuncToken, SStrToken *endToken, int32_t optType) {
   if (pFuncToken == NULL) return NULL;
 
   tSQLExpr *pExpr = calloc(1, sizeof(tSQLExpr));
@@ -173,8 +177,12 @@ tSQLExpr *tSQLExprCreateFunction(tSQLExprList *pList, SSQLToken *pFuncToken, SSQ
 tSQLExpr *tSQLExprCreate(tSQLExpr *pLeft, tSQLExpr *pRight, int32_t optrType) {
   tSQLExpr *pExpr = calloc(1, sizeof(tSQLExpr));
 
-  if (optrType == TK_PLUS || optrType == TK_MINUS || optrType == TK_STAR || optrType == TK_DIVIDE ||
-      optrType == TK_REM) {
+  char* endPos = pRight->token.z + pRight->token.n;
+  pExpr->token.z = pLeft->token.z;
+  pExpr->token.n = endPos - pExpr->token.z;
+  pExpr->token.type = pLeft->token.type;
+
+  if (optrType == TK_PLUS || optrType == TK_MINUS || optrType == TK_STAR || optrType == TK_DIVIDE || optrType == TK_REM) {
     /*
      * if a token is noted as the TK_TIMESTAMP, the time precision is microsecond
      * Otherwise, the time precision is adaptive, determined by the time precision from databases.
@@ -373,7 +381,7 @@ void tVariantListDestroy(tVariantList *pList) {
   free(pList);
 }
 
-tVariantList *tVariantListAppendToken(tVariantList *pList, SSQLToken *pAliasToken, uint8_t sortOrder) {
+tVariantList *tVariantListAppendToken(tVariantList *pList, SStrToken *pToken, uint8_t sortOrder) {
   if (pList == NULL) {
     pList = calloc(1, sizeof(tVariantList));
   }
@@ -382,9 +390,9 @@ tVariantList *tVariantListAppendToken(tVariantList *pList, SSQLToken *pAliasToke
     return pList;
   }
 
-  if (pAliasToken) {
+  if (pToken) {
     tVariant t = {0};
-    tVariantCreate(&t, pAliasToken);
+    tVariantCreate(&t, pToken);
 
     tVariantListItem *pItem = &pList->a[pList->nExpr++];
     memcpy(pItem, &t, sizeof(tVariant));
@@ -420,7 +428,7 @@ void tFieldListDestroy(tFieldList *pList) {
   free(pList);
 }
 
-void setDBName(SSQLToken *pCpxName, SSQLToken *pDB) {
+void setDBName(SStrToken *pCpxName, SStrToken *pDB) {
   pCpxName->type = pDB->type;
   pCpxName->z = pDB->z;
   pCpxName->n = pDB->n;
@@ -464,7 +472,7 @@ int32_t getTimestampInUsFromStrImpl(int64_t val, char unit, int64_t *result) {
   return 0;
 }
 
-void tSQLSetColumnInfo(TAOS_FIELD *pField, SSQLToken *pName, TAOS_FIELD *pType) {
+void tSQLSetColumnInfo(TAOS_FIELD *pField, SStrToken *pName, TAOS_FIELD *pType) {
   int32_t maxLen = sizeof(pField->name) / sizeof(pField->name[0]);
   
   // truncate the column name
@@ -479,7 +487,7 @@ void tSQLSetColumnInfo(TAOS_FIELD *pField, SSQLToken *pName, TAOS_FIELD *pType)
   pField->bytes = pType->bytes;
 }
 
-void tSQLSetColumnType(TAOS_FIELD *pField, SSQLToken *type) {
+void tSQLSetColumnType(TAOS_FIELD *pField, SStrToken *type) {
   pField->type = -1;
 
   int32_t LENGTH_SIZE_OF_STR = 2;  // in case of nchar and binary, there two bytes to keep the length of binary|nchar.
@@ -517,9 +525,9 @@ void tSQLSetColumnType(TAOS_FIELD *pField, SSQLToken *type) {
 /*
  * extract the select info out of sql string
  */
-SQuerySQL *tSetQuerySQLElems(SSQLToken *pSelectToken, tSQLExprList *pSelection, tVariantList *pFrom, tSQLExpr *pWhere,
-                             tVariantList *pGroupby, tVariantList *pSortOrder, SSQLToken *pInterval,
-                             SSQLToken *pSliding, tVariantList *pFill, SLimitVal *pLimit, SLimitVal *pGLimit) {
+SQuerySQL *tSetQuerySQLElems(SStrToken *pSelectToken, tSQLExprList *pSelection, tVariantList *pFrom, tSQLExpr *pWhere,
+                             tVariantList *pGroupby, tVariantList *pSortOrder, SStrToken *pInterval,
+                             SStrToken *pSliding, tVariantList *pFill, SLimitVal *pLimit, SLimitVal *pGLimit) {
   assert(pSelection != NULL);
 
   SQuerySQL *pQuery = calloc(1, sizeof(SQuerySQL));
@@ -611,7 +619,7 @@ void destroyAllSelectClause(SSubclauseInfo *pClause) {
   taosTFree(pClause->pClause);
 }
 
-SCreateTableSQL *tSetCreateSQLElems(tFieldList *pCols, tFieldList *pTags, SSQLToken *pStableName,
+SCreateTableSQL *tSetCreateSQLElems(tFieldList *pCols, tFieldList *pTags, SStrToken *pStableName,
                                     tVariantList *pTagVals, SQuerySQL *pSelect, int32_t type) {
   SCreateTableSQL *pCreate = calloc(1, sizeof(SCreateTableSQL));
 
@@ -644,7 +652,7 @@ SCreateTableSQL *tSetCreateSQLElems(tFieldList *pCols, tFieldList *pTags, SSQLTo
   return pCreate;
 }
 
-SAlterTableSQL *tAlterTableSQLElems(SSQLToken *pMeterName, tFieldList *pCols, tVariantList *pVals, int32_t type) {
+SAlterTableSQL *tAlterTableSQLElems(SStrToken *pMeterName, tFieldList *pCols, tVariantList *pVals, int32_t type) {
   SAlterTableSQL *pAlterTable = calloc(1, sizeof(SAlterTableSQL));
   
   pAlterTable->name = *pMeterName;
@@ -716,7 +724,7 @@ SSubclauseInfo* setSubclause(SSubclauseInfo* pSubclause, void *pSqlExprInfo) {
   return pSubclause;
 }
 
-SSqlInfo* setSQLInfo(SSqlInfo *pInfo, void *pSqlExprInfo, SSQLToken *pMeterName, int32_t type) {
+SSqlInfo* setSQLInfo(SSqlInfo *pInfo, void *pSqlExprInfo, SStrToken *pMeterName, int32_t type) {
   pInfo->type = type;
   
   if (type == TSDB_SQL_SELECT) {
@@ -745,7 +753,7 @@ SSubclauseInfo* appendSelectClause(SSubclauseInfo *pQueryInfo, void *pSubclause)
   return pQueryInfo;
 }
 
-void setCreatedTableName(SSqlInfo *pInfo, SSQLToken *pMeterName, SSQLToken *pIfNotExists) {
+void setCreatedTableName(SSqlInfo *pInfo, SStrToken *pMeterName, SStrToken *pIfNotExists) {
   pInfo->pCreateTableInfo->name = *pMeterName;
   pInfo->pCreateTableInfo->existCheck = (pIfNotExists->n != 0);
 }
@@ -760,7 +768,7 @@ void tTokenListBuyMoreSpace(tDCLSQL *pTokenList) {
   }
 }
 
-tDCLSQL *tTokenListAppend(tDCLSQL *pTokenList, SSQLToken *pToken) {
+tDCLSQL *tTokenListAppend(tDCLSQL *pTokenList, SStrToken *pToken) {
   if (pToken == NULL) return NULL;
 
   if (pTokenList == NULL) pTokenList = calloc(1, sizeof(tDCLSQL));
@@ -781,19 +789,19 @@ void setDCLSQLElems(SSqlInfo *pInfo, int32_t type, int32_t nParam, ...) {
   va_start(va, nParam);
 
   while (nParam-- > 0) {
-    SSQLToken *pToken = va_arg(va, SSQLToken *);
+    SStrToken *pToken = va_arg(va, SStrToken *);
     pInfo->pDCLInfo = tTokenListAppend(pInfo->pDCLInfo, pToken);
   }
   va_end(va);
 }
 
-void setDropDBTableInfo(SSqlInfo *pInfo, int32_t type, SSQLToken* pToken, SSQLToken* existsCheck) {
+void setDropDBTableInfo(SSqlInfo *pInfo, int32_t type, SStrToken* pToken, SStrToken* existsCheck) {
   pInfo->type = type;
   pInfo->pDCLInfo = tTokenListAppend(pInfo->pDCLInfo, pToken);
   pInfo->pDCLInfo->existsCheck = (existsCheck->n == 1);
 }
 
-void setShowOptions(SSqlInfo *pInfo, int32_t type, SSQLToken* prefix, SSQLToken* pPatterns) {
+void setShowOptions(SSqlInfo *pInfo, int32_t type, SStrToken* prefix, SStrToken* pPatterns) {
   if (pInfo->pDCLInfo == NULL) {
     pInfo->pDCLInfo = calloc(1, sizeof(tDCLSQL));
   }
@@ -816,7 +824,7 @@ void setShowOptions(SSqlInfo *pInfo, int32_t type, SSQLToken* prefix, SSQLToken*
   }
 }
 
-void setCreateDBSQL(SSqlInfo *pInfo, int32_t type, SSQLToken *pToken, SCreateDBInfo *pDB, SSQLToken *pIgExists) {
+void setCreateDBSQL(SSqlInfo *pInfo, int32_t type, SStrToken *pToken, SCreateDBInfo *pDB, SStrToken *pIgExists) {
   pInfo->type = type;
   if (pInfo->pDCLInfo == NULL) {
     pInfo->pDCLInfo = calloc(1, sizeof(tDCLSQL));
@@ -827,7 +835,7 @@ void setCreateDBSQL(SSqlInfo *pInfo, int32_t type, SSQLToken *pToken, SCreateDBI
   pInfo->pDCLInfo->dbOpt.ignoreExists = pIgExists->n; // sql.y has: ifnotexists(X) ::= IF NOT EXISTS.   {X.n = 1;}
 }
 
-void setCreateAcctSQL(SSqlInfo *pInfo, int32_t type, SSQLToken *pName, SSQLToken *pPwd, SCreateAcctSQL *pAcctInfo) {
+void setCreateAcctSQL(SSqlInfo *pInfo, int32_t type, SStrToken *pName, SStrToken *pPwd, SCreateAcctSQL *pAcctInfo) {
   pInfo->type = type;
   if (pInfo->pDCLInfo == NULL) {
     pInfo->pDCLInfo = calloc(1, sizeof(tDCLSQL));
@@ -843,7 +851,7 @@ void setCreateAcctSQL(SSqlInfo *pInfo, int32_t type, SSQLToken *pName, SSQLToken
   }
 }
 
-void setCreateUserSQL(SSqlInfo *pInfo, SSQLToken *pName, SSQLToken *pPasswd) {
+void setCreateUserSQL(SSqlInfo *pInfo, SStrToken *pName, SStrToken *pPasswd) {
   pInfo->type = TSDB_SQL_CREATE_USER;
   if (pInfo->pDCLInfo == NULL) {
     pInfo->pDCLInfo = calloc(1, sizeof(tDCLSQL));
@@ -855,7 +863,7 @@ void setCreateUserSQL(SSqlInfo *pInfo, SSQLToken *pName, SSQLToken *pPasswd) {
   pInfo->pDCLInfo->user.passwd = *pPasswd;
 }
 
-void setAlterUserSQL(SSqlInfo *pInfo, int16_t type, SSQLToken *pName, SSQLToken* pPwd, SSQLToken *pPrivilege) {
+void setAlterUserSQL(SSqlInfo *pInfo, int16_t type, SStrToken *pName, SStrToken* pPwd, SStrToken *pPrivilege) {
   pInfo->type = TSDB_SQL_ALTER_USER;
   if (pInfo->pDCLInfo == NULL) {
     pInfo->pDCLInfo = calloc(1, sizeof(tDCLSQL));
@@ -880,7 +888,7 @@ void setAlterUserSQL(SSqlInfo *pInfo, int16_t type, SSQLToken *pName, SSQLToken*
   }
 }
 
-void setKillSQL(SSqlInfo *pInfo, int32_t type, SSQLToken *ip) {
+void setKillSQL(SSqlInfo *pInfo, int32_t type, SStrToken *ip) {
   pInfo->type = type;
   if (pInfo->pDCLInfo == NULL) {
     pInfo->pDCLInfo = calloc(1, sizeof(tDCLSQL));
@@ -909,5 +917,5 @@ void setDefaultCreateDbOption(SCreateDBInfo *pDBInfo) {
   pDBInfo->quorum = -1;
   pDBInfo->keep = NULL;
 
-  memset(&pDBInfo->precision, 0, sizeof(SSQLToken));
+  memset(&pDBInfo->precision, 0, sizeof(SStrToken));
 }
diff --git a/src/query/src/qTokenizer.c b/src/query/src/qTokenizer.c
index 6fb63c4a20b7a4045959176c068354a3fce9fefe..5fdabca166131b84e27e3a79b56b6535a4672971 100644
--- a/src/query/src/qTokenizer.c
+++ b/src/query/src/qTokenizer.c
@@ -580,8 +580,8 @@ uint32_t tSQLGetToken(char* z, uint32_t* tokenType) {
   return 0;
 }
 
-SSQLToken tStrGetToken(char* str, int32_t* i, bool isPrevOptr, uint32_t numOfIgnoreToken, uint32_t* ignoreTokenTypes) {
-  SSQLToken t0 = {0};
+SStrToken tStrGetToken(char* str, int32_t* i, bool isPrevOptr, uint32_t numOfIgnoreToken, uint32_t* ignoreTokenTypes) {
+  SStrToken t0 = {0};
 
   // here we reach the end of sql string, null-terminated string
   if (str[*i] == 0) {
diff --git a/src/query/src/sql.c b/src/query/src/sql.c
index 0b977977af87850567120eb8d946442b6d08d64e..f3f55791b09809cab42793e491b59f36143ebfd3 100644
--- a/src/query/src/sql.c
+++ b/src/query/src/sql.c
@@ -99,7 +99,7 @@
 #define YYCODETYPE unsigned short int
 #define YYNOCODE 274
 #define YYACTIONTYPE unsigned short int
-#define ParseTOKENTYPE SSQLToken
+#define ParseTOKENTYPE SStrToken
 typedef union {
   int yyinit;
   ParseTOKENTYPE yy0;
@@ -2074,21 +2074,21 @@ static void yy_reduce(
         break;
       case 22: /* cmd ::= SHOW dbPrefix STABLES LIKE ids */
 {
-    SSQLToken token;
+    SStrToken token;
     setDBName(&token, &yymsp[-3].minor.yy0);
     setShowOptions(pInfo, TSDB_MGMT_TABLE_METRIC, &token, &yymsp[0].minor.yy0);
 }
         break;
       case 23: /* cmd ::= SHOW dbPrefix VGROUPS */
 {
-    SSQLToken token;
+    SStrToken token;
     setDBName(&token, &yymsp[-1].minor.yy0);
     setShowOptions(pInfo, TSDB_MGMT_TABLE_VGROUP, &token, 0);
 }
         break;
       case 24: /* cmd ::= SHOW dbPrefix VGROUPS ids */
 {
-    SSQLToken token;
+    SStrToken token;
     setDBName(&token, &yymsp[-2].minor.yy0);    
     setShowOptions(pInfo, TSDB_MGMT_TABLE_VGROUP, &token, &yymsp[0].minor.yy0);
 }
@@ -2139,7 +2139,7 @@ static void yy_reduce(
 { setDCLSQLElems(pInfo, TSDB_SQL_CFG_LOCAL, 2, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);          }
         break;
       case 38: /* cmd ::= ALTER DATABASE ids alter_db_optr */
-{ SSQLToken t = {0};  setCreateDBSQL(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy268, &t);}
+{ SStrToken t = {0};  setCreateDBSQL(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy268, &t);}
         break;
       case 39: /* cmd ::= ALTER ACCOUNT ids acct_optr */
 { setCreateAcctSQL(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy149);}
diff --git a/src/query/tests/unitTest.cpp b/src/query/tests/unitTest.cpp
index b59e0783a2b3c264e8a4353bbe1e405991953635..b6e1170d0ef989a7fe4bad43a29ccfb357005883 100644
--- a/src/query/tests/unitTest.cpp
+++ b/src/query/tests/unitTest.cpp
@@ -16,7 +16,7 @@
 
 namespace {
 int32_t testValidateName(char* name) {
-  SSQLToken token = {0};
+  SStrToken token = {0};
   token.z = name;
   token.n = strlen(name);
   token.type = 0;
@@ -720,8 +720,8 @@ TEST(testCase, tGetToken_Test) {
   EXPECT_FALSE(type == TK_HEX);
 }
 
-static SSQLToken createStrToken(char* s) {
-  SSQLToken t = {0};//.type = TK_STRING, .z = s, .n = strlen(s)};
+static SStrToken createStrToken(char* s) {
+  SStrToken t = {0};//.type = TK_STRING, .z = s, .n = strlen(s)};
   t.type = TK_STRING;
   t.z = s;
   t.n = strlen(s);
@@ -730,7 +730,7 @@ static SSQLToken createStrToken(char* s) {
 }
 
 TEST(testCase, isValidNumber_test) {
-  SSQLToken t1 = createStrToken("123abc");
+  SStrToken t1 = createStrToken("123abc");
 
   EXPECT_EQ(isValidNumber(&t1), TK_ILLEGAL);
 
diff --git a/src/util/inc/tstoken.h b/src/util/inc/tstoken.h
index c1c6f2de7a6dcf5c96f14513f877ff1bf3e1a5de..7aeb2da6b658f4b8fd1cc7e03583a3cc676ea237 100644
--- a/src/util/inc/tstoken.h
+++ b/src/util/inc/tstoken.h
@@ -28,11 +28,11 @@ extern "C" {
 #define TSQL_TBNAME_L "tbname"
 
 // used to denote the minimum unite in sql parsing
-typedef struct SSQLToken {
+typedef struct SStrToken {
   uint32_t n;
   uint32_t type;
   char *   z;
-} SSQLToken;
+} SStrToken;
 
 /**
  * tokenizer for sql string
@@ -52,7 +52,7 @@ uint32_t tSQLGetToken(char *z, uint32_t *tokenType);
  * @param ignoreTokenTypes
  * @return
  */
-SSQLToken tStrGetToken(char *str, int32_t *i, bool isPrevOptr, uint32_t numOfIgnoreToken, uint32_t *ignoreTokenTypes);
+SStrToken tStrGetToken(char *str, int32_t *i, bool isPrevOptr, uint32_t numOfIgnoreToken, uint32_t *ignoreTokenTypes);
 
 /**
  * check if it is a keyword or not
@@ -76,7 +76,7 @@ bool isKeyWord(const char *z, int32_t len);
  * @param pToken
  * @return        token type, if it is not a number, TK_ILLEGAL will return
  */
-static FORCE_INLINE int32_t isValidNumber(const SSQLToken* pToken) {
+static FORCE_INLINE int32_t isValidNumber(const SStrToken* pToken) {
   const char* z = pToken->z;
   int32_t type = TK_ILLEGAL;
 
diff --git a/tests/script/general/parser/bug.sim b/tests/script/general/parser/constCol.sim
similarity index 100%
rename from tests/script/general/parser/bug.sim
rename to tests/script/general/parser/constCol.sim
diff --git a/tests/script/general/parser/testSuite.sim b/tests/script/general/parser/testSuite.sim
index aafba2d328eea518f8292c138fed60084c79bc42..4e26d14cfd7f67cc925d1360460cc2625afd7eaa 100644
--- a/tests/script/general/parser/testSuite.sim
+++ b/tests/script/general/parser/testSuite.sim
@@ -97,7 +97,7 @@ run general/parser/topbot.sim
 sleep 2000
 run general/parser/union.sim
 sleep 2000
-run general/parser/bug.sim
+run general/parser/constCol.sim
 sleep 2000
 run general/parser/sliding.sim