diff --git a/src/client/inc/tscUtil.h b/src/client/inc/tscUtil.h
index e9f077fe5331a1b2dd414b6c10656be53cb07ebf..c16945bbcf35ac5247ecbb505aaf667870fc9d09 100644
--- a/src/client/inc/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@@ -113,7 +113,8 @@ bool tscIsSelectivityWithTagQuery(SSqlCmd* pCmd);
 void tscAddSpecialColumnForSelect(SQueryInfo* pQueryInfo, int32_t outputColIndex, int16_t functionId, SColumnIndex* pIndex,
                                   SSchema* pColSchema, int16_t isTag);
 
-void addRequiredTagColumn(SQueryInfo* pQueryInfo, int32_t tagColIndex, int32_t tableIndex);
+//void addRequiredTagColumn(SQueryInfo* pQueryInfo, int32_t tagColIndex, int32_t tableIndex);
+void addRequiredTagColumn(STableMetaInfo* pTableMetaInfo, SColumnIndex* index);
 
 int32_t tscSetTableId(STableMetaInfo* pTableMetaInfo, SSQLToken* pzTableName, SSqlObj* pSql);
 void    tscClearInterpInfo(SQueryInfo* pQueryInfo);
@@ -148,10 +149,10 @@ void addExprParams(SSqlExpr* pExpr, char* argument, int32_t type, int32_t bytes,
 int32_t   tscGetResRowLength(SArray* pExprList);
 
 SSqlExpr* tscSqlExprInsert(SQueryInfo* pQueryInfo, int32_t index, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
-    int16_t size, int16_t interSize);
+    int16_t size, int16_t interSize, bool isTagCol);
 
 SSqlExpr* tscSqlExprAppend(SQueryInfo* pQueryInfo, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
-                           int16_t size, int16_t interSize);
+                           int16_t size, int16_t interSize, bool isTagCol);
 
 SSqlExpr* tscSqlExprUpdate(SQueryInfo* pQueryInfo, int32_t index, int16_t functionId, int16_t srcColumnIndex, int16_t type,
                            int16_t size);
@@ -198,7 +199,7 @@ int32_t tscGetQueryInfoDetailSafely(SSqlCmd *pCmd, int32_t subClauseIndex, SQuer
 void tscClearMeterMetaInfo(STableMetaInfo* pTableMetaInfo, bool removeFromCache);
 
 STableMetaInfo* tscAddTableMetaInfo(SQueryInfo* pQueryInfo, const char* name, STableMeta* pTableMeta,
-    SVgroupsInfo* vgroupList, int16_t numOfTags, int16_t* tags);
+    SVgroupsInfo* vgroupList, SArray* pTagCols);
 
 STableMetaInfo* tscAddEmptyMetaInfo(SQueryInfo *pQueryInfo);
 int32_t tscAddSubqueryInfo(SSqlCmd *pCmd);
diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index 337b6b96287725773d7bf48797f9891b82a13580..9cc6bcb364b76b8156a95cefb34afb27d41a599f 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -78,8 +78,7 @@ typedef struct STableMetaInfo {
    */
   int32_t vgroupIndex;
   char    name[TSDB_TABLE_ID_LEN];        // (super) table name
-  int16_t numOfTags;                      // total required tags in query, including groupby tags
-  int16_t tagColumnIndex[TSDB_MAX_TAGS];  // clause + tag projection
+  SArray* tagColList;                     // involved tag columns
 } STableMetaInfo;
 
 /* the structure for sql function in select clause */
@@ -221,7 +220,7 @@ typedef struct SQueryInfo {
   int64_t          clauseLimit;  // limit for current sub clause
 
   // offset value in the original sql expression, NOT sent to virtual node, only applied at client side
-  int64_t prjOffset;
+  int64_t          prjOffset;
 } SQueryInfo;
 
 typedef struct {
diff --git a/src/client/src/tscLocal.c b/src/client/src/tscLocal.c
index a2006b9a139c8011d1d4322766243b82eac6601d..7ace940a1e9103640c6810b9e46c4e036f27f39b 100644
--- a/src/client/src/tscLocal.c
+++ b/src/client/src/tscLocal.c
@@ -247,7 +247,8 @@ static int32_t tscBuildMeterSchemaResultFields(SSqlObj *pSql, int32_t numOfCols,
   strncpy(f.name, "Field", TSDB_COL_NAME_LEN);
   
   SFieldSupInfo* pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
-  pInfo->pSqlExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, TSDB_COL_NAME_LEN, TSDB_COL_NAME_LEN);
+  pInfo->pSqlExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, TSDB_COL_NAME_LEN,
+      TSDB_COL_NAME_LEN, false);
   
   rowLen += TSDB_COL_NAME_LEN;
 
@@ -256,7 +257,8 @@ static int32_t tscBuildMeterSchemaResultFields(SSqlObj *pSql, int32_t numOfCols,
   strncpy(f.name, "Type", TSDB_COL_NAME_LEN);
   
   pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
-  pInfo->pSqlExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, typeColLength, typeColLength);
+  pInfo->pSqlExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, typeColLength,
+      typeColLength, false);
   
   rowLen += typeColLength;
 
@@ -265,7 +267,8 @@ static int32_t tscBuildMeterSchemaResultFields(SSqlObj *pSql, int32_t numOfCols,
   strncpy(f.name, "Length", TSDB_COL_NAME_LEN);
   
   pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
-  pInfo->pSqlExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_INT, sizeof(int32_t), sizeof(int32_t));
+  pInfo->pSqlExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_INT, sizeof(int32_t),
+      sizeof(int32_t), false);
   
   rowLen += sizeof(int32_t);
 
@@ -274,7 +277,8 @@ static int32_t tscBuildMeterSchemaResultFields(SSqlObj *pSql, int32_t numOfCols,
   strncpy(f.name, "Note", TSDB_COL_NAME_LEN);
   
   pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
-  pInfo->pSqlExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, noteColLength, noteColLength);
+  pInfo->pSqlExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, noteColLength,
+      noteColLength, false);
   
   rowLen += noteColLength;
   return rowLen;
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 3abbe346ace2f536c407dcfe9ab9349fac7c1249..df47afd0dcf2cd50e6dfa11b3ddd7ce40e95d877 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -649,7 +649,8 @@ int32_t parseIntervalClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySql) {
   }
 
   SColumnIndex index = {tableIndex, PRIMARYKEY_TIMESTAMP_COL_INDEX};
-  SSqlExpr* pExpr = tscSqlExprInsert(pQueryInfo, 0, TSDB_FUNC_TS, &index, TSDB_DATA_TYPE_TIMESTAMP, TSDB_KEYSIZE, TSDB_KEYSIZE);
+  SSqlExpr* pExpr = tscSqlExprInsert(pQueryInfo, 0, TSDB_FUNC_TS, &index, TSDB_DATA_TYPE_TIMESTAMP, TSDB_KEYSIZE,
+      TSDB_KEYSIZE, false);
 
   SColumnList ids = getColumnList(1, 0, PRIMARYKEY_TIMESTAMP_COL_INDEX);
 
@@ -1169,7 +1170,7 @@ int32_t parseSelectClause(SSqlCmd* pCmd, int32_t clauseIndex, tSQLExprList* pSel
         // expr string is set as the parameter of function
         SColumnIndex index = {.tableIndex = tableIndex};
         SSqlExpr*    pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_ARITHM, &index, TSDB_DATA_TYPE_DOUBLE,
-                                              sizeof(double), sizeof(double));
+                                              sizeof(double), sizeof(double), false);
         addExprParams(pExpr, arithmeticExprStr, TSDB_DATA_TYPE_BINARY, strlen(arithmeticExprStr), index.tableIndex);
   
         /* todo alias name should use the original sql string */
@@ -1270,7 +1271,16 @@ int32_t parseSelectClause(SSqlCmd* pCmd, int32_t clauseIndex, tSQLExprList* pSel
 
 int32_t insertResultField(SQueryInfo* pQueryInfo, int32_t outputIndex, SColumnList* pIdList, int16_t bytes,
     int8_t type, char* fieldName, SSqlExpr* pSqlExpr) {
+  
   for (int32_t i = 0; i < pIdList->num; ++i) {
+    int32_t tableId = pIdList->ids[i].tableIndex;
+    STableMetaInfo* pTableMetaInfo = pQueryInfo->pTableMetaInfo[tableId];
+    
+    int32_t numOfCols = tscGetNumOfColumns(pTableMetaInfo->pTableMeta);
+    if (pIdList->ids[i].columnIndex >= numOfCols) {
+      continue;
+    }
+    
     tscColumnListInsert(pQueryInfo->colList, &(pIdList->ids[i]));
   }
   
@@ -1289,37 +1299,46 @@ SSqlExpr* doAddProjectCol(SQueryInfo* pQueryInfo, int32_t outputIndex, int32_t c
   SSchema* pSchema = tscGetTableColumnSchema(pTableMeta, colIndex);
 
   int16_t functionId = (int16_t)((colIndex >= numOfCols) ? TSDB_FUNC_TAGPRJ : TSDB_FUNC_PRJ);
-  pQueryInfo->type = (functionId == TSDB_FUNC_TAGPRJ)? TSDB_QUERY_TYPE_STABLE_QUERY:TSDB_QUERY_TYPE_PROJECTION_QUERY;
-
-  SColumnIndex index = {tableIndex, colIndex};
-  return tscSqlExprAppend(pQueryInfo, functionId, &index, pSchema->type, pSchema->bytes, pSchema->bytes);
+  SColumnIndex index = {.tableIndex = tableIndex,};
+  
+  if (functionId == TSDB_FUNC_TAGPRJ) {
+    index.columnIndex = colIndex - tscGetNumOfColumns(pTableMeta);
+    
+    addRequiredTagColumn(pTableMetaInfo, &index);
+    pQueryInfo->type = TSDB_QUERY_TYPE_STABLE_QUERY;
+  } else {
+    index.columnIndex = colIndex;
+    pQueryInfo->type = TSDB_QUERY_TYPE_PROJECTION_QUERY;
+  }
+  
+  return tscSqlExprAppend(pQueryInfo, functionId, &index, pSchema->type, pSchema->bytes,
+      pSchema->bytes, functionId == TSDB_FUNC_TAGPRJ);
 }
 
-void addRequiredTagColumn(SQueryInfo* pQueryInfo, int32_t tagColIndex, int32_t tableIndex) {
-  STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, tableIndex);
-
-  if (pTableMetaInfo->numOfTags == 0 || pTableMetaInfo->tagColumnIndex[pTableMetaInfo->numOfTags - 1] < tagColIndex) {
-    pTableMetaInfo->tagColumnIndex[pTableMetaInfo->numOfTags++] = tagColIndex;
-  } else {  // find the appropriate position
-    for (int32_t i = 0; i < pTableMetaInfo->numOfTags; ++i) {
-      if (tagColIndex > pTableMetaInfo->tagColumnIndex[i]) {
-        continue;
-      } else if (tagColIndex == pTableMetaInfo->tagColumnIndex[i]) {
-        break;
-      } else {
-        memmove(&pTableMetaInfo->tagColumnIndex[i + 1], &pTableMetaInfo->tagColumnIndex[i],
-                sizeof(pTableMetaInfo->tagColumnIndex[0]) * (pTableMetaInfo->numOfTags - i));
-
-        pTableMetaInfo->tagColumnIndex[i] = tagColIndex;
-
-        pTableMetaInfo->numOfTags++;
-        break;
-      }
-    }
-  }
+void addRequiredTagColumn(STableMetaInfo* pTableMetaInfo, SColumnIndex* index) {
+  tscColumnListInsert(pTableMetaInfo->tagColList, index);
+//  if (pTableMetaInfo->numOfTags == 0 || pTableMetaInfo->tagColumnIndex[pTableMetaInfo->numOfTags - 1] < tagColIndex) {
+//    pTableMetaInfo->tagColumnIndex[pTableMetaInfo->numOfTags++] = tagColIndex;
+//  } else {  // find the appropriate position
+//    for (int32_t i = 0; i < pTableMetaInfo->numOfTags; ++i) {
+//      if (tagColIndex > pTableMetaInfo->tagColumnIndex[i]) {
+//        continue;
+//      } else if (tagColIndex == pTableMetaInfo->tagColumnIndex[i]) {
+//        break;
+//      } else {
+//        memmove(&pTableMetaInfo->tagColumnIndex[i + 1], &pTableMetaInfo->tagColumnIndex[i],
+//                sizeof(pTableMetaInfo->tagColumnIndex[0]) * (pTableMetaInfo->numOfTags - i));
+//
+//        pTableMetaInfo->tagColumnIndex[i] = tagColIndex;
+//
+//        pTableMetaInfo->numOfTags++;
+//        break;
+//      }
+//    }
+//  }
 
   // plus one means tbname
-  assert(tagColIndex >= -1 && tagColIndex < TSDB_MAX_TAGS && pTableMetaInfo->numOfTags <= TSDB_MAX_TAGS + 1);
+//  assert(tagColIndex >= -1 && tagColIndex < TSDB_MAX_TAGS && pTableMetaInfo->numOfTags <= TSDB_MAX_TAGS + 1);
 }
 
 static void addProjectQueryCol(SQueryInfo* pQueryInfo, int32_t startPos, SColumnIndex* pIndex, tSQLExprItem* pItem) {
@@ -1347,7 +1366,7 @@ static void addProjectQueryCol(SQueryInfo* pQueryInfo, int32_t startPos, SColumn
 void tscAddSpecialColumnForSelect(SQueryInfo* pQueryInfo, int32_t outputColIndex, int16_t functionId,
                                   SColumnIndex* pIndex, SSchema* pColSchema, int16_t flag) {
   SSqlExpr* pExpr = tscSqlExprAppend(pQueryInfo, functionId, pIndex, pColSchema->type,
-                                     pColSchema->bytes, pColSchema->bytes);
+                                     pColSchema->bytes, pColSchema->bytes, flag);
 
   SColumnList ids = getColumnList(1, pIndex->tableIndex, pIndex->columnIndex);
   if (TSDB_COL_IS_TAG(flag)) {
@@ -1357,8 +1376,10 @@ void tscAddSpecialColumnForSelect(SQueryInfo* pQueryInfo, int32_t outputColIndex
   insertResultField(pQueryInfo, outputColIndex, &ids, pColSchema->bytes, pColSchema->type, pColSchema->name, pExpr);
 
   pExpr->colInfo.flag = flag;
+  STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, pIndex->tableIndex);
+  
   if (TSDB_COL_IS_TAG(flag)) {
-    addRequiredTagColumn(pQueryInfo, pIndex->columnIndex, pIndex->tableIndex);
+    addRequiredTagColumn(pTableMetaInfo, pIndex);
   }
 }
 
@@ -1384,7 +1405,6 @@ static int32_t doAddProjectionExprAndResultFields(SQueryInfo* pQueryInfo, SColum
     pIndex->columnIndex = j;
     SColumnList ids = {0};
     ids.ids[0] = *pIndex;
-
     ids.num = 1;
 
     insertResultField(pQueryInfo, startPos + j, &ids, pSchema[j].bytes, pSchema[j].type, pSchema[j].name, pExpr);
@@ -1474,7 +1494,7 @@ static int32_t setExprInfoForFunctions(SQueryInfo* pQueryInfo, SSchema* pSchema,
     getRevisedName(columnName, functionID, TSDB_COL_NAME_LEN, pSchema[pColIndex->columnIndex].name);
   }
   
-  SSqlExpr* pExpr = tscSqlExprAppend(pQueryInfo, functionID, pColIndex, type, bytes, bytes);
+  SSqlExpr* pExpr = tscSqlExprAppend(pQueryInfo, functionID, pColIndex, type, bytes, bytes, false);
   strncpy(pExpr->aliasName, columnName, tListLen(pExpr->aliasName));
   
   // for all queries, the timestamp column needs to be loaded
@@ -1531,7 +1551,7 @@ int32_t addExprAndResultField(SQueryInfo* pQueryInfo, int32_t colIndex, tSQLExpr
 
           index = (SColumnIndex){0, PRIMARYKEY_TIMESTAMP_COL_INDEX};
           int32_t size = tDataTypeDesc[TSDB_DATA_TYPE_BIGINT].nSize;
-          pExpr = tscSqlExprAppend(pQueryInfo, functionID, &index, TSDB_DATA_TYPE_BIGINT, size, size);
+          pExpr = tscSqlExprAppend(pQueryInfo, functionID, &index, TSDB_DATA_TYPE_BIGINT, size, size, false);
         } else {
           // count the number of meters created according to the metric
           if (getColumnIndexByName(pToken, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
@@ -1546,13 +1566,13 @@ int32_t addExprAndResultField(SQueryInfo* pQueryInfo, int32_t colIndex, tSQLExpr
           }
 
           int32_t size = tDataTypeDesc[TSDB_DATA_TYPE_BIGINT].nSize;
-          pExpr = tscSqlExprAppend(pQueryInfo, functionID, &index, TSDB_DATA_TYPE_BIGINT, size, size);
+          pExpr = tscSqlExprAppend(pQueryInfo, functionID, &index, TSDB_DATA_TYPE_BIGINT, size, size, false);
         }
       } else {  // count(*) is equalled to count(primary_timestamp_key)
         index = (SColumnIndex){0, PRIMARYKEY_TIMESTAMP_COL_INDEX};
 
         int32_t size = tDataTypeDesc[TSDB_DATA_TYPE_BIGINT].nSize;
-        pExpr = tscSqlExprAppend(pQueryInfo, functionID, &index, TSDB_DATA_TYPE_BIGINT, size, size);
+        pExpr = tscSqlExprAppend(pQueryInfo, functionID, &index, TSDB_DATA_TYPE_BIGINT, size, size, false);
       }
       
       memset(pExpr->aliasName, 0, tListLen(pExpr->aliasName));
@@ -1633,7 +1653,7 @@ int32_t addExprAndResultField(SQueryInfo* pQueryInfo, int32_t colIndex, tSQLExpr
         colIndex += 1;
         SColumnIndex indexTS = {.tableIndex = index.tableIndex, .columnIndex = 0};
         SSqlExpr* pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &indexTS, TSDB_DATA_TYPE_TIMESTAMP, TSDB_KEYSIZE,
-                         TSDB_KEYSIZE);
+                         TSDB_KEYSIZE, false);
 
         SColumnList ids = getColumnList(1, 0, 0);
         insertResultField(pQueryInfo, 0, &ids, TSDB_KEYSIZE, TSDB_DATA_TYPE_TIMESTAMP, aAggs[TSDB_FUNC_TS_DUMMY].aName, pExpr);
@@ -1644,7 +1664,7 @@ int32_t addExprAndResultField(SQueryInfo* pQueryInfo, int32_t colIndex, tSQLExpr
         return invalidSqlErrMsg(pQueryInfo->msg, msg6);
       }
 
-      SSqlExpr* pExpr = tscSqlExprAppend(pQueryInfo, functionID, &index, resultType, resultSize, resultSize);
+      SSqlExpr* pExpr = tscSqlExprAppend(pQueryInfo, functionID, &index, resultType, resultSize, resultSize, false);
 
       if (optr == TK_LEASTSQUARES) {
         /* set the leastsquares parameters */
@@ -1836,7 +1856,7 @@ int32_t addExprAndResultField(SQueryInfo* pQueryInfo, int32_t colIndex, tSQLExpr
           return TSDB_CODE_INVALID_SQL;
         }
 
-        pExpr = tscSqlExprAppend(pQueryInfo, functionId, &index, resultType, resultSize, resultSize);
+        pExpr = tscSqlExprAppend(pQueryInfo, functionId, &index, resultType, resultSize, resultSize, false);
         addExprParams(pExpr, val, TSDB_DATA_TYPE_DOUBLE, sizeof(double), 0);
       } else {
         tVariantDump(pVariant, val, TSDB_DATA_TYPE_BIGINT);
@@ -1853,7 +1873,8 @@ int32_t addExprAndResultField(SQueryInfo* pQueryInfo, int32_t colIndex, tSQLExpr
 
         // set the first column ts for top/bottom query
         SColumnIndex index1 = {0, PRIMARYKEY_TIMESTAMP_COL_INDEX};
-        pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS, &index1, TSDB_DATA_TYPE_TIMESTAMP, TSDB_KEYSIZE, TSDB_KEYSIZE);
+        pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS, &index1, TSDB_DATA_TYPE_TIMESTAMP, TSDB_KEYSIZE,
+            TSDB_KEYSIZE, false);
 
         const int32_t TS_COLUMN_INDEX = 0;
         SColumnList   ids = getColumnList(1, 0, TS_COLUMN_INDEX);
@@ -1862,7 +1883,7 @@ int32_t addExprAndResultField(SQueryInfo* pQueryInfo, int32_t colIndex, tSQLExpr
 
         colIndex += 1;  // the first column is ts
 
-        pExpr = tscSqlExprAppend(pQueryInfo, functionId, &index, resultType, resultSize, resultSize);
+        pExpr = tscSqlExprAppend(pQueryInfo, functionId, &index, resultType, resultSize, resultSize, false);
         addExprParams(pExpr, val, TSDB_DATA_TYPE_BIGINT, sizeof(int64_t), 0);
       }
   
@@ -2338,10 +2359,15 @@ bool hasUnsupportFunctionsForSTableQuery(SQueryInfo* pQueryInfo) {
       return true;
     }
 
-    if (pQueryInfo->groupbyExpr.numOfGroupCols != 1 ||
-        pQueryInfo->groupbyExpr.columnInfo[0].colIndex != TSDB_TBNAME_COLUMN_INDEX) {
+    if (pQueryInfo->groupbyExpr.numOfGroupCols != 1) {
       invalidSqlErrMsg(pQueryInfo->msg, msg2);
       return true;
+    } else {
+      SColIndex* pColIndex = taosArrayGet(pQueryInfo->groupbyExpr.columnInfo, 0);
+      if (pColIndex->colIndex != TSDB_TBNAME_COLUMN_INDEX) {
+        invalidSqlErrMsg(pQueryInfo->msg, msg2);
+        return true;
+      }
     }
   }
 
@@ -2385,72 +2411,55 @@ static bool functionCompatibleCheck(SQueryInfo* pQueryInfo) {
 }
 
 void updateTagColumnIndex(SQueryInfo* pQueryInfo, int32_t tableIndex) {
-  STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, tableIndex);
-
-  /*
-   * update tags column index for group by tags
-   * group by columns belong to this table
-   */
-  if (pQueryInfo->groupbyExpr.numOfGroupCols > 0 && pQueryInfo->groupbyExpr.tableIndex == tableIndex) {
-    for (int32_t i = 0; i < pQueryInfo->groupbyExpr.numOfGroupCols; ++i) {
-      int32_t index = pQueryInfo->groupbyExpr.columnInfo[i].colIndex;
-
-      for (int32_t j = 0; j < pTableMetaInfo->numOfTags; ++j) {
-        int32_t tagColIndex = pTableMetaInfo->tagColumnIndex[j];
-        if (tagColIndex == index) {
-          pQueryInfo->groupbyExpr.columnInfo[i].colIndex = j;
-          break;
-        }
-      }
-    }
-  }
-
-  // update tags column index for expression
-  size_t size = tscSqlExprNumOfExprs(pQueryInfo);
-  for (int32_t i = 0; i < size; ++i) {
-    SSqlExpr* pExpr = tscSqlExprGet(pQueryInfo, i);
-
-    if (!TSDB_COL_IS_TAG(pExpr->colInfo.flag)) {  // not tags, continue
-      continue;
-    }
-
-    // not belongs to this table
-    if (pExpr->uid != pTableMetaInfo->pTableMeta->uid) {
-      continue;
-    }
+//  STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, tableIndex);
+//
+//  // update tags column index for expression
+//  size_t size = tscSqlExprNumOfExprs(pQueryInfo);
+//  for (int32_t i = 0; i < size; ++i) {
+//    SSqlExpr* pExpr = tscSqlExprGet(pQueryInfo, i);
+//
+//    if (!TSDB_COL_IS_TAG(pExpr->colInfo.flag)) {  // not tags, continue
+//      continue;
+//    }
+//
+//    // not belongs to this table
+//    if (pExpr->uid != pTableMetaInfo->pTableMeta->uid) {
+//      continue;
+//    }
 
-    for (int32_t j = 0; j < pTableMetaInfo->numOfTags; ++j) {
-      if (pExpr->colInfo.colIndex == pTableMetaInfo->tagColumnIndex[j]) {
-        pExpr->colInfo.colIndex = j;
-        break;
-      }
-    }
-  }
+//    for (int32_t j = 0; j < pTableMetaInfo->numOfTags; ++j) {
+//      if (pExpr->colInfo.colIndex == pTableMetaInfo->tagColumnIndex[j]) {
+//        pExpr->colInfo.colIndex = j;
+//        break;
+//      }
+//    }
+//  }
 
   // update join condition tag column index
-  SJoinInfo* pJoinInfo = &pQueryInfo->tagCond.joinInfo;
-  if (!pJoinInfo->hasJoin) {  // not join query
-    return;
-  }
-
-  assert(pJoinInfo->left.uid != pJoinInfo->right.uid);
-
-  // the join condition expression node belongs to this table(super table)
-  if (pTableMetaInfo->pTableMeta->uid == pJoinInfo->left.uid) {
-    for (int32_t i = 0; i < pTableMetaInfo->numOfTags; ++i) {
-      if (pJoinInfo->left.tagCol == pTableMetaInfo->tagColumnIndex[i]) {
-        pJoinInfo->left.tagCol = i;
-      }
-    }
-  }
-
-  if (pTableMetaInfo->pTableMeta->uid == pJoinInfo->right.uid) {
-    for (int32_t i = 0; i < pTableMetaInfo->numOfTags; ++i) {
-      if (pJoinInfo->right.tagCol == pTableMetaInfo->tagColumnIndex[i]) {
-        pJoinInfo->right.tagCol = i;
-      }
-    }
-  }
+//  SJoinInfo* pJoinInfo = &pQueryInfo->tagCond.joinInfo;
+//  if (!pJoinInfo->hasJoin) {  // not join query
+//    return;
+//  }
+//
+//  assert(pJoinInfo->left.uid != pJoinInfo->right.uid);
+//
+//  // the join condition expression node belongs to this table(super table)
+//  assert(0);
+//  if (pTableMetaInfo->pTableMeta->uid == pJoinInfo->left.uid) {
+//    for (int32_t i = 0; i < pTableMetaInfo->numOfTags; ++i) {
+//      if (pJoinInfo->left.tagCol == pTableMetaInfo->tagColumnIndex[i]) {
+//        pJoinInfo->left.tagCol = i;
+//      }
+//    }
+//  }
+//
+//  if (pTableMetaInfo->pTableMeta->uid == pJoinInfo->right.uid) {
+//    for (int32_t i = 0; i < pTableMetaInfo->numOfTags; ++i) {
+//      if (pJoinInfo->right.tagCol == pTableMetaInfo->tagColumnIndex[i]) {
+//        pJoinInfo->right.tagCol = i;
+//      }
+//    }
+//  }
 }
 
 int32_t parseGroupbyClause(SQueryInfo* pQueryInfo, tVariantList* pList, SSqlCmd* pCmd) {
@@ -2478,7 +2487,7 @@ int32_t parseGroupbyClause(SQueryInfo* pQueryInfo, tVariantList* pList, SSqlCmd*
   SSchema     s = tscGetTbnameColumnSchema();
 
   int32_t tableIndex = COLUMN_INDEX_INITIAL_VAL;
-
+  
   for (int32_t i = 0; i < pList->nExpr; ++i) {
     tVariant* pVar = &pList->a[i].pVar;
     SSQLToken token = {pVar->nLen, pVar->nType, pVar->pz};
@@ -2496,7 +2505,8 @@ int32_t parseGroupbyClause(SQueryInfo* pQueryInfo, tVariantList* pList, SSqlCmd*
 
     pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
     pTableMeta = pTableMetaInfo->pTableMeta;
-
+  
+    int32_t numOfCols = tscGetNumOfColumns(pTableMeta);
     if (index.columnIndex == TSDB_TBNAME_COLUMN_INDEX) {
       pSchema = &s;
     } else {
@@ -2504,23 +2514,31 @@ int32_t parseGroupbyClause(SQueryInfo* pQueryInfo, tVariantList* pList, SSqlCmd*
     }
 
     bool groupTag = false;
-    if (index.columnIndex == TSDB_TBNAME_COLUMN_INDEX || index.columnIndex >= tscGetNumOfColumns(pTableMeta)) {
+    if (index.columnIndex == TSDB_TBNAME_COLUMN_INDEX || index.columnIndex >= numOfCols) {
       groupTag = true;
     }
-
+  
+    SSqlGroupbyExpr* pGroupExpr = &pQueryInfo->groupbyExpr;
+    if (pGroupExpr->columnInfo == NULL) {
+      pGroupExpr->columnInfo = taosArrayInit(4, sizeof(SColIndex));
+    }
+    
     if (groupTag) {
       if (!UTIL_TABLE_IS_SUPERTABLE(pTableMetaInfo)) {
         return invalidSqlErrMsg(pQueryInfo->msg, msg9);
       }
 
-//      int32_t relIndex = index.columnIndex;
-//      if (index.columnIndex != TSDB_TBNAME_COLUMN_INDEX) {
-//        relIndex -= tscGetNumOfColumns(pTableMeta);
-//      }
+      int32_t relIndex = index.columnIndex;
+      if (index.columnIndex != TSDB_TBNAME_COLUMN_INDEX) {
+        relIndex -= numOfCols;
+      }
 
-      pQueryInfo->groupbyExpr.columnInfo[i] =
-          (SColIndex){.colIndex = index.columnIndex, .flag = TSDB_COL_TAG, .colId = pSchema->colId};  // relIndex;
-      addRequiredTagColumn(pQueryInfo, pQueryInfo->groupbyExpr.columnInfo[i].colIndex, index.tableIndex);
+      SColIndex colIndex = {
+          .colIndex = relIndex, .flag = TSDB_COL_TAG, .colId = pSchema->colId,
+      };
+      
+      taosArrayPush(pGroupExpr->columnInfo, &colIndex);
+      addRequiredTagColumn(pTableMetaInfo, &index);
     } else {
       // check if the column type is valid, here only support the bool/tinyint/smallint/bigint group by
       if (pSchema->type > TSDB_DATA_TYPE_BINARY) {
@@ -2528,8 +2546,11 @@ int32_t parseGroupbyClause(SQueryInfo* pQueryInfo, tVariantList* pList, SSqlCmd*
       }
 
       tscColumnListInsert(pQueryInfo->colList, &index);
-      pQueryInfo->groupbyExpr.columnInfo[i] =
-          (SColIndex){.colIndex = index.columnIndex, .flag = TSDB_COL_NORMAL, .colId = pSchema->colId};  // relIndex;
+      
+      SColIndex colIndex = {
+          .colIndex = index.columnIndex, .flag = TSDB_COL_NORMAL, .colId = pSchema->colId,
+      };
+      taosArrayPush(pGroupExpr->columnInfo, &colIndex);
       pQueryInfo->groupbyExpr.orderType = TSDB_ORDER_ASC;
 
       if (i == 0 && pList->nExpr > 1) {
@@ -3524,7 +3545,7 @@ static int32_t setTableCondForSTableQuery(SQueryInfo* pQueryInfo, const char* ac
     return TSDB_CODE_SUCCESS;
   }
 
-  SStringBuilder sb1 = {0};
+  SStringBuilder sb1;
   taosStringBuilderAppendStringLen(&sb1, QUERY_COND_REL_PREFIX_IN, QUERY_COND_REL_PREFIX_IN_LEN);
 
   char db[TSDB_TABLE_ID_LEN] = {0};
@@ -3707,14 +3728,14 @@ static void doAddJoinTagsColumnsIntoTagList(SQueryInfo* pQueryInfo, SCondExpr* p
     getColumnIndexByName(&pCondExpr->pJoinExpr->pLeft->colInfo, pQueryInfo, &index);
     pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
 
-    int32_t columnInfo = index.columnIndex - tscGetNumOfColumns(pTableMetaInfo->pTableMeta);
-    addRequiredTagColumn(pQueryInfo, columnInfo, index.tableIndex);
+//    int32_t columnInfo = index.columnIndex - tscGetNumOfColumns(pTableMetaInfo->pTableMeta);
+    addRequiredTagColumn(pTableMetaInfo, &index);
 
     getColumnIndexByName(&pCondExpr->pJoinExpr->pRight->colInfo, pQueryInfo, &index);
     pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
 
-    columnInfo = index.columnIndex - tscGetNumOfColumns(pTableMetaInfo->pTableMeta);
-    addRequiredTagColumn(pQueryInfo, columnInfo, index.tableIndex);
+//    columnInfo = index.columnIndex - tscGetNumOfColumns(pTableMetaInfo->pTableMeta);
+    addRequiredTagColumn(pTableMetaInfo, &index);
   }
 }
 
@@ -4106,7 +4127,9 @@ int32_t parseOrderbyClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySql, SSchema
 
     if (index.columnIndex >= tscGetNumOfColumns(pTableMetaInfo->pTableMeta)) {
       int32_t relTagIndex = index.columnIndex - tscGetNumOfColumns(pTableMetaInfo->pTableMeta);
-      if (relTagIndex == pQueryInfo->groupbyExpr.columnInfo[0].colIndex) {
+      
+      SColIndex* pColIndex = taosArrayGet(pQueryInfo->groupbyExpr.columnInfo, 0);
+      if (relTagIndex == pColIndex->colIndex) {
         orderByTags = true;
       }
     } else if (index.columnIndex == TSDB_TBNAME_COLUMN_INDEX) {
@@ -4816,7 +4839,7 @@ void tscAddTimestampColumn(SQueryInfo* pQueryInfo, int16_t functionId, int16_t t
   if (pExpr == NULL || pExpr->colInfo.colId != PRIMARYKEY_TIMESTAMP_COL_INDEX || pExpr->functionId != functionId) {
     SColumnIndex index = {tableIndex, PRIMARYKEY_TIMESTAMP_COL_INDEX};
 
-    pExpr = tscSqlExprAppend(pQueryInfo, functionId, &index, TSDB_DATA_TYPE_TIMESTAMP, TSDB_KEYSIZE, TSDB_KEYSIZE);
+    pExpr = tscSqlExprAppend(pQueryInfo, functionId, &index, TSDB_DATA_TYPE_TIMESTAMP, TSDB_KEYSIZE, TSDB_KEYSIZE, false);
     pExpr->colInfo.flag = TSDB_COL_NORMAL;
 
     // NOTE: tag column does not add to source column list
@@ -4845,7 +4868,7 @@ void addGroupInfoForSubquery(SSqlObj* pParentObj, SSqlObj* pSql, int32_t subClau
       int16_t bytes = pSchema[index.columnIndex].bytes;
       char*   name = pSchema[index.columnIndex].name;
   
-      pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TAG, &index, type, bytes, bytes);
+      pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TAG, &index, type, bytes, bytes, true);
       pExpr->colInfo.flag = TSDB_COL_TAG;
 
       // NOTE: tag column does not add to source column list
@@ -4855,9 +4878,11 @@ void addGroupInfoForSubquery(SSqlObj* pParentObj, SSqlObj* pSql, int32_t subClau
       int32_t relIndex = index.columnIndex;
 
       pExpr->colInfo.colIndex = relIndex;
-      pQueryInfo->groupbyExpr.columnInfo[0].colIndex = relIndex;
+      SColIndex* pColIndex = taosArrayGet(pQueryInfo->groupbyExpr.columnInfo, 0);
+      pColIndex->colIndex = relIndex;
 
-      addRequiredTagColumn(pQueryInfo, pQueryInfo->groupbyExpr.columnInfo[0].colIndex, 0);
+      index = (SColumnIndex) {.tableIndex = tableIndex, .columnIndex = relIndex};
+      addRequiredTagColumn(pTableMetaInfo, &index);
     }
   }
 }
@@ -4870,15 +4895,17 @@ static void doLimitOutputNormalColOfGroupby(SSqlExpr* pExpr) {
 }
 
 void doAddGroupColumnForSubquery(SQueryInfo* pQueryInfo, int32_t tagIndex) {
-  int32_t index = pQueryInfo->groupbyExpr.columnInfo[tagIndex].colIndex;
-
+  SColIndex* pColIndex = taosArrayGet(pQueryInfo->groupbyExpr.columnInfo, tagIndex);
+  int32_t index = pColIndex->colIndex;
+  
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
 
   SSchema*     pSchema = tscGetTableColumnSchema(pTableMetaInfo->pTableMeta, index);
   SColumnIndex colIndex = {.tableIndex = 0, .columnIndex = index};
   
   size_t size = tscSqlExprNumOfExprs(pQueryInfo);
-  SSqlExpr* pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_PRJ, &colIndex, pSchema->type, pSchema->bytes, pSchema->bytes);
+  SSqlExpr* pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_PRJ, &colIndex, pSchema->type, pSchema->bytes,
+      pSchema->bytes, false);
 
   pExpr->colInfo.flag = TSDB_COL_NORMAL;
   doLimitOutputNormalColOfGroupby(pExpr);
@@ -4930,7 +4957,9 @@ static void doUpdateSqlFunctionForColPrj(SQueryInfo* pQueryInfo) {
     if (pExpr->functionId == TSDB_FUNC_PRJ) {
       bool qualifiedCol = false;
       for (int32_t j = 0; j < pQueryInfo->groupbyExpr.numOfGroupCols; ++j) {
-        if (pExpr->colInfo.colId == pQueryInfo->groupbyExpr.columnInfo[j].colId) {
+        SColIndex* pColIndex = taosArrayGet(pQueryInfo->groupbyExpr.columnInfo, j);
+  
+        if (pExpr->colInfo.colId == pColIndex->colId) {
           qualifiedCol = true;
           doLimitOutputNormalColOfGroupby(pExpr);
           pExpr->numOfParams = 1;
@@ -4945,7 +4974,9 @@ static void doUpdateSqlFunctionForColPrj(SQueryInfo* pQueryInfo) {
 
 static bool tagColumnInGroupby(SSqlGroupbyExpr* pGroupbyExpr, int16_t columnId) {
   for (int32_t j = 0; j < pGroupbyExpr->numOfGroupCols; ++j) {
-    if (columnId == pGroupbyExpr->columnInfo[j].colId && pGroupbyExpr->columnInfo[j].flag == TSDB_COL_TAG) {
+    SColIndex* pColIndex = taosArrayGet(pGroupbyExpr->columnInfo, j);
+  
+    if (columnId == pColIndex->colId && pColIndex->flag == TSDB_COL_TAG) {
       return true;
     }
   }
@@ -5103,26 +5134,32 @@ static int32_t doAddGroupbyColumnsOnDemand(SQueryInfo* pQueryInfo) {
   char*    name = NULL;
 
   for (int32_t i = 0; i < pQueryInfo->groupbyExpr.numOfGroupCols; ++i) {
-    SColIndex* pColIndex = &pQueryInfo->groupbyExpr.columnInfo[i];
-
+    SColIndex* pColIndex = taosArrayGet(pQueryInfo->groupbyExpr.columnInfo, i);
+  
     int16_t colIndex = pColIndex->colIndex;
-    if (pColIndex->colIndex == TSDB_TBNAME_COLUMN_INDEX) {
+    if (colIndex == TSDB_TBNAME_COLUMN_INDEX) {
       type = TSDB_DATA_TYPE_BINARY;
       bytes = TSDB_TABLE_NAME_LEN;
       name = TSQL_TBNAME_L;
     } else {
-//      colIndex = (TSDB_COL_IS_TAG(pColIndex->flag)) ? tscGetNumOfColumns(pTableMetaInfo->pTableMeta) + pColIndex->colIndex
-//                                                    : pColIndex->colIndex;
-      type = pSchema[colIndex].type;
-      bytes = pSchema[colIndex].bytes;
-      name = pSchema[colIndex].name;
+      if (TSDB_COL_IS_TAG(pColIndex->flag)) {
+        SSchema* tagSchema = tscGetTableTagSchema(pTableMetaInfo->pTableMeta);
+        
+        type  = tagSchema[colIndex].type;
+        bytes = tagSchema[colIndex].bytes;
+        name  = tagSchema[colIndex].name;
+      } else {
+        type  = pSchema[colIndex].type;
+        bytes = pSchema[colIndex].bytes;
+        name  = pSchema[colIndex].name;
+      }
     }
   
     size_t size = tscSqlExprNumOfExprs(pQueryInfo);
   
     if (TSDB_COL_IS_TAG(pColIndex->flag)) {
       SColumnIndex index = {.tableIndex = pQueryInfo->groupbyExpr.tableIndex, .columnIndex = colIndex};
-      SSqlExpr* pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TAG, &index, type, bytes, bytes);
+      SSqlExpr* pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TAG, &index, type, bytes, bytes, true);
       
       memset(pExpr->aliasName, 0, tListLen(pExpr->aliasName));
       strncpy(pExpr->aliasName, name, TSDB_COL_NAME_LEN);
@@ -5131,7 +5168,7 @@ static int32_t doAddGroupbyColumnsOnDemand(SQueryInfo* pQueryInfo) {
 
       // NOTE: tag column does not add to source column list
       SColumnList ids = getColumnList(1, 0, pColIndex->colIndex);
-      insertResultField(pQueryInfo, size - 1, &ids, bytes, type, name, pExpr);
+      insertResultField(pQueryInfo, size, &ids, bytes, type, name, pExpr);
     } else {
       // if this query is "group by" normal column, interval is not allowed
       if (pQueryInfo->intervalTime > 0) {
@@ -5194,7 +5231,7 @@ int32_t doFunctionsCompatibleCheck(SSqlCmd* pCmd, SQueryInfo* pQueryInfo) {
       if (functId == TSDB_FUNC_PRJ && pExpr->colInfo.colId != PRIMARYKEY_TIMESTAMP_COL_INDEX) {
         bool qualified = false;
         for (int32_t j = 0; j < pQueryInfo->groupbyExpr.numOfGroupCols; ++j) {
-          SColIndex* pColIndex = &pQueryInfo->groupbyExpr.columnInfo[j];
+          SColIndex* pColIndex = taosArrayGet(pQueryInfo->groupbyExpr.columnInfo, j);
           if (pColIndex->colId == pExpr->colInfo.colId) {
             qualified = true;
             break;
@@ -5272,7 +5309,7 @@ int32_t doLocalQueryProcess(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySql) {
 
   SColumnIndex ind = {0};
   SSqlExpr* pExpr1 = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TAG_DUMMY, &ind, TSDB_DATA_TYPE_INT,
-      tDataTypeDesc[TSDB_DATA_TYPE_INT].nSize, tDataTypeDesc[TSDB_DATA_TYPE_INT].nSize);
+      tDataTypeDesc[TSDB_DATA_TYPE_INT].nSize, tDataTypeDesc[TSDB_DATA_TYPE_INT].nSize, false);
   
   const char* name = (pExprList->a[0].aliasName != NULL)? pExprList->a[0].aliasName:functionsInfo[index].name;
   strncpy(pExpr1->aliasName, name, tListLen(pExpr1->aliasName));
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index bab66bcc184dae3ff33f268a27f0ee8a9b7e8571..5ae8f2402bf0dfdaddd73afcfd4bfbd77c6f7949 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -642,8 +642,9 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
   SQueryTableMsg *pQueryMsg = (SQueryTableMsg *)pStart;
 
-  int32_t msgLen = 0;
+  int32_t msgLen      = 0;
   int32_t numOfTables = 0;
+  int32_t numOfTags   = taosArrayGetSize(pTableMetaInfo->tagColList);
 
   if (UTIL_TABLE_IS_NOMRAL_TABLE(pTableMetaInfo)) {
     numOfTables = 1;
@@ -652,7 +653,6 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
     tscTrace("%p queried tables:%d, table id: %s", pSql, 1, pTableMetaInfo->name);
   } else {  // query super table
     int32_t index = pTableMetaInfo->vgroupIndex;
-    
     if (index < 0) {
       tscError("%p error vgroupIndex:%d", pSql, index);
       return -1;
@@ -693,8 +693,9 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   pQueryMsg->slidingTime    = htobe64(pQueryInfo->slidingTime);
   pQueryMsg->slidingTimeUnit = pQueryInfo->slidingTimeUnit;
   pQueryMsg->numOfGroupCols = htons(pQueryInfo->groupbyExpr.numOfGroupCols);
-
-  pQueryMsg->queryType = htons(pQueryInfo->type);
+  pQueryMsg->numOfTags      = htonl(numOfTags);
+  
+  pQueryMsg->queryType      = htons(pQueryInfo->type);
   
   size_t numOfOutput = tscSqlExprNumOfExprs(pQueryInfo);
   pQueryMsg->numOfOutput = htons(numOfOutput);
@@ -708,12 +709,11 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   char *pMsg = (char *)(pQueryMsg->colList) + numOfCols * sizeof(SColumnInfo);
   SSchema *pSchema = tscGetTableSchema(pTableMeta);
   
-  int32_t total = tscGetNumOfColumns(pTableMeta) + tscGetNumOfTags(pTableMeta);
   for (int32_t i = 0; i < numOfCols; ++i) {
     SColumn *pCol = taosArrayGetP(pQueryInfo->colList, i);
     SSchema *pColSchema = &pSchema[pCol->colIndex.columnIndex];
 
-    if (pCol->colIndex.columnIndex >= total || pColSchema->type < TSDB_DATA_TYPE_BOOL ||
+    if (pCol->colIndex.columnIndex >= tscGetNumOfColumns(pTableMeta) || pColSchema->type < TSDB_DATA_TYPE_BOOL ||
         pColSchema->type > TSDB_DATA_TYPE_NCHAR) {
       tscError("%p sid:%d uid:%" PRIu64" id:%s, column index out of range, numOfColumns:%d, index:%d, column name:%s",
           pSql, pTableMeta->sid, pTableMeta->uid, pTableMetaInfo->name, tscGetNumOfColumns(pTableMeta), pCol->colIndex,
@@ -766,7 +766,7 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
     }
 
     if (!tscValidateColumnId(pTableMetaInfo, pExpr->colInfo.colId)) {
-      /* column id is not valid according to the cached metermeta, the table meta is expired */
+      /* column id is not valid according to the cached table meta, the table meta is expired */
       tscError("%p table schema is not matched with parsed sql", pSql);
       return -1;
     }
@@ -822,8 +822,8 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
     pQueryMsg->orderType = htons(pGroupbyExpr->orderType);
 
     for (int32_t j = 0; j < pGroupbyExpr->numOfGroupCols; ++j) {
-      SColIndex *pCol = &pGroupbyExpr->columnInfo[j];
-
+      SColIndex* pCol = taosArrayGet(pGroupbyExpr->columnInfo, j);
+  
       *((int16_t *)pMsg) = pCol->colId;
       pMsg += sizeof(pCol->colId);
 
@@ -844,6 +844,37 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
       pMsg += sizeof(pQueryInfo->defaultVal[0]);
     }
   }
+  
+  if (numOfTags != 0) {
+    int32_t numOfColumns = tscGetNumOfColumns(pTableMeta);
+    int32_t numOfTagColumns = tscGetNumOfTags(pTableMeta);
+    int32_t total = numOfTagColumns + numOfColumns;
+    
+    pSchema = tscGetTableTagSchema(pTableMeta);
+    
+    for (int32_t i = 0; i < numOfTags; ++i) {
+      SColumn *pCol = taosArrayGetP(pQueryInfo->colList, i);
+      SSchema *pColSchema = &pSchema[pCol->colIndex.columnIndex];
+
+      if ((pCol->colIndex.columnIndex >= numOfTagColumns || pCol->colIndex.columnIndex < -1) ||
+          (pColSchema->type < TSDB_DATA_TYPE_BOOL || pColSchema->type > TSDB_DATA_TYPE_NCHAR)) {
+        tscError("%p sid:%d uid:%" PRIu64 " id:%s, tag index out of range, totalCols:%d, numOfTags:%d, index:%d, column name:%s",
+                 pSql, pTableMeta->sid, pTableMeta->uid, pTableMetaInfo->name, total, numOfTagColumns,
+                 pCol->colIndex, pColSchema->name);
+
+        return TSDB_CODE_INVALID_SQL;
+      }
+  
+      SColumnInfo* pTagCol = (SColumnInfo*) pMsg;
+  
+      pTagCol->colId = htons(pColSchema->colId);
+      pTagCol->bytes = htons(pColSchema->bytes);
+      pTagCol->type  = htons(pColSchema->type);
+      pTagCol->numOfFilters = 0;
+      
+      pMsg += sizeof(SColumnInfo);
+    }
+  }
 
   // compressed ts block
   pQueryMsg->tsOffset = htonl(pMsg - pStart);
@@ -2200,7 +2231,7 @@ int tscProcessShowRsp(SSqlObj *pSql) {
     SFieldSupInfo* pInfo = tscFieldInfoAppend(pFieldInfo, &f);
     
     pInfo->pSqlExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index,
-                     pTableSchema[i].type, pTableSchema[i].bytes, pTableSchema[i].bytes);
+                     pTableSchema[i].type, pTableSchema[i].bytes, pTableSchema[i].bytes, false);
   }
   
   pCmd->numOfCols = pQueryInfo->fieldsInfo.numOfOutput;
@@ -2543,7 +2574,7 @@ int tscGetSTableVgroupInfo(SSqlObj *pSql, int32_t clauseIndex) {
     STableMetaInfo *pMMInfo = tscGetMetaInfo(pQueryInfo, i);
 
     STableMeta *pTableMeta = taosCacheAcquireByName(tscCacheHandle, pMMInfo->name);
-    tscAddTableMetaInfo(pNewQueryInfo, pMMInfo->name, pTableMeta, NULL, pMMInfo->numOfTags, pMMInfo->tagColumnIndex);
+    tscAddTableMetaInfo(pNewQueryInfo, pMMInfo->name, pTableMeta, NULL, pMMInfo->tagColList);
   }
 
   if ((code = tscAllocPayload(&pNew->cmd, TSDB_DEFAULT_PAYLOAD_SIZE)) != TSDB_CODE_SUCCESS) {
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index 18a39acc0f70b97446994d239deb6bfbca53169e..abdab2d9a162faf544dfbf7daa958b657aaa446f 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -947,7 +947,7 @@ void tscFieldInfoClear(SFieldInfo* pFieldInfo) {
 }
 
 static SSqlExpr* doBuildSqlExpr(SQueryInfo* pQueryInfo, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
-    int16_t size, int16_t interSize) {
+    int16_t size, int16_t interSize, bool isTagCol) {
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, pColIndex->tableIndex);
   
   SSqlExpr* pExpr = calloc(1, sizeof(SSqlExpr));
@@ -958,22 +958,19 @@ static SSqlExpr* doBuildSqlExpr(SQueryInfo* pQueryInfo, int16_t functionId, SCol
   if (pColIndex->columnIndex == TSDB_TBNAME_COLUMN_INDEX) {
     pExpr->colInfo.colId = TSDB_TBNAME_COLUMN_INDEX;
   } else {
-    SSchema* pSchema = tscGetTableColumnSchema(pTableMetaInfo->pTableMeta, pColIndex->columnIndex);
-    pExpr->colInfo.colId = pSchema->colId;
-  }
-  
-  // tag columns require the column index revised.
-  int16_t numOfCols = tscGetNumOfColumns(pTableMetaInfo->pTableMeta);
-  if (pColIndex->columnIndex >= numOfCols) {
-    pExpr->colInfo.flag = TSDB_COL_TAG;
-  } else {
-    if (pColIndex->columnIndex != TSDB_TBNAME_COLUMN_INDEX) {
-      pExpr->colInfo.flag = TSDB_COL_NORMAL;
+    if (isTagCol) {
+      SSchema* pSchema = tscGetTableTagSchema(pTableMetaInfo->pTableMeta);
+      pExpr->colInfo.colId = pSchema[pColIndex->columnIndex].colId;
+      strncpy(pExpr->colInfo.name, pSchema[pColIndex->columnIndex].name, TSDB_COL_NAME_LEN);
     } else {
-      pExpr->colInfo.flag = TSDB_COL_TAG;
+      SSchema* pSchema = tscGetTableColumnSchema(pTableMetaInfo->pTableMeta, pColIndex->columnIndex);
+      pExpr->colInfo.colId = pSchema->colId;
+      strncpy(pExpr->colInfo.name, pSchema->name, TSDB_COL_NAME_LEN);
     }
   }
   
+  pExpr->colInfo.flag = isTagCol? TSDB_COL_TAG:TSDB_COL_NORMAL;
+  
   pExpr->colInfo.colIndex = pColIndex->columnIndex;
   pExpr->resType       = type;
   pExpr->resBytes      = size;
@@ -984,20 +981,20 @@ static SSqlExpr* doBuildSqlExpr(SQueryInfo* pQueryInfo, int16_t functionId, SCol
 }
 
 SSqlExpr* tscSqlExprInsert(SQueryInfo* pQueryInfo, int32_t index, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
-                           int16_t size, int16_t interSize) {
+                           int16_t size, int16_t interSize, bool isTagCol) {
   int32_t num = taosArrayGetSize(pQueryInfo->exprsInfo);
   if (index == num) {
-    return tscSqlExprAppend(pQueryInfo, functionId, pColIndex, type, size, interSize);
+    return tscSqlExprAppend(pQueryInfo, functionId, pColIndex, type, size, interSize, isTagCol);
   }
   
-  SSqlExpr* pExpr = doBuildSqlExpr(pQueryInfo, functionId, pColIndex, type, size, interSize);
+  SSqlExpr* pExpr = doBuildSqlExpr(pQueryInfo, functionId, pColIndex, type, size, interSize, isTagCol);
   taosArrayInsert(pQueryInfo->exprsInfo, index, &pExpr);
   return pExpr;
 }
 
 SSqlExpr* tscSqlExprAppend(SQueryInfo* pQueryInfo, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
-    int16_t size, int16_t interSize) {
-  SSqlExpr* pExpr = doBuildSqlExpr(pQueryInfo, functionId, pColIndex, type, size, interSize);
+    int16_t size, int16_t interSize, bool isTagCol) {
+  SSqlExpr* pExpr = doBuildSqlExpr(pQueryInfo, functionId, pColIndex, type, size, interSize, isTagCol);
   taosArrayPush(pQueryInfo->exprsInfo, &pExpr);
   return pExpr;
 }
@@ -1431,9 +1428,9 @@ void tscGetSrcColumnInfo(SSrcColumnInfo* pColInfo, SQueryInfo* pQueryInfo) {
 
     if (TSDB_COL_IS_TAG(pExpr->colInfo.flag)) {
       SSchema* pTagSchema = tscGetTableTagSchema(pTableMetaInfo->pTableMeta);
-      int16_t  actualTagIndex = pTableMetaInfo->tagColumnIndex[pExpr->colInfo.colIndex];
-
-      pColInfo[i].type = (actualTagIndex != -1) ? pTagSchema[actualTagIndex].type : TSDB_DATA_TYPE_BINARY;
+      
+      int16_t index = pExpr->colInfo.colIndex;
+      pColInfo[i].type = (index != -1) ? pTagSchema[index].type : TSDB_DATA_TYPE_BINARY;
     } else {
       pColInfo[i].type = pSchema[pExpr->colInfo.colIndex].type;
     }
@@ -1645,7 +1642,7 @@ void tscFreeSubqueryInfo(SSqlCmd* pCmd) {
 }
 
 STableMetaInfo* tscAddTableMetaInfo(SQueryInfo* pQueryInfo, const char* name, STableMeta* pTableMeta,
-                                    SVgroupsInfo* vgroupList, int16_t numOfTags, int16_t* tags) {
+                                    SVgroupsInfo* vgroupList, SArray* pTagCols) {
   void* pAlloc = realloc(pQueryInfo->pTableMetaInfo, (pQueryInfo->numOfTables + 1) * POINTER_BYTES);
   if (pAlloc == NULL) {
     return NULL;
@@ -1663,7 +1660,6 @@ STableMetaInfo* tscAddTableMetaInfo(SQueryInfo* pQueryInfo, const char* name, ST
   }
 
   pTableMetaInfo->pTableMeta = pTableMeta;
-  pTableMetaInfo->numOfTags = numOfTags;
   
   if (vgroupList != NULL) {
     assert(vgroupList->numOfVgroups == 1);  // todo fix me
@@ -1674,16 +1670,18 @@ STableMetaInfo* tscAddTableMetaInfo(SQueryInfo* pQueryInfo, const char* name, ST
     memcpy(pTableMetaInfo->vgroupList, vgroupList, size);
   }
 
-  if (tags != NULL) {
-    memcpy(pTableMetaInfo->tagColumnIndex, tags, sizeof(pTableMetaInfo->tagColumnIndex[0]) * numOfTags);
+  if (pTagCols == NULL) {
+    pTableMetaInfo->tagColList = taosArrayInit(4, sizeof(SColumnIndex));
+  } else {
+    pTableMetaInfo->tagColList = taosArrayClone(pTagCols);
   }
-
+  
   pQueryInfo->numOfTables += 1;
   return pTableMetaInfo;
 }
 
 STableMetaInfo* tscAddEmptyMetaInfo(SQueryInfo* pQueryInfo) {
-  return tscAddTableMetaInfo(pQueryInfo, NULL, NULL, NULL, 0, NULL);
+  return tscAddTableMetaInfo(pQueryInfo, NULL, NULL, NULL, NULL);
 }
 
 void doRemoveTableMetaInfo(SQueryInfo* pQueryInfo, int32_t index, bool removeFromCache) {
@@ -1857,17 +1855,15 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, void (*fp)(), void
   if (pPrevSql == NULL) {
     STableMeta* pTableMeta = taosCacheAcquireByName(tscCacheHandle, name);
 
-    pFinalInfo = tscAddTableMetaInfo(pNewQueryInfo, name, pTableMeta, pTableMetaInfo->vgroupList, pTableMetaInfo->numOfTags,
-                                     pTableMetaInfo->tagColumnIndex);
+    pFinalInfo = tscAddTableMetaInfo(pNewQueryInfo, name, pTableMeta, pTableMetaInfo->vgroupList, pTableMetaInfo->tagColList);
   } else {  // transfer the ownership of pTableMeta to the newly create sql object.
     STableMetaInfo* pPrevInfo = tscGetTableMetaInfoFromCmd(&pPrevSql->cmd, pPrevSql->cmd.clauseIndex, 0);
 
     STableMeta*  pPrevTableMeta = taosCacheTransfer(tscCacheHandle, (void**)&pPrevInfo->pTableMeta);
+    
     SVgroupsInfo* pVgroupsInfo = pPrevInfo->vgroupList;
     pPrevInfo->vgroupList = NULL;
-    
-    pFinalInfo = tscAddTableMetaInfo(pNewQueryInfo, name, pPrevTableMeta, pVgroupsInfo, pTableMetaInfo->numOfTags,
-                                     pTableMetaInfo->tagColumnIndex);
+    pFinalInfo = tscAddTableMetaInfo(pNewQueryInfo, name, pPrevTableMeta, pVgroupsInfo, pTableMetaInfo->tagColList);
   }
 
   assert(pFinalInfo->pTableMeta != NULL && pNewQueryInfo->numOfTables == 1);
diff --git a/src/inc/taosmsg.h b/src/inc/taosmsg.h
index 636d5b863ba05af546776825e53a6a4c6421e43d..d32dfad59cafa48d3ac2d569527a412263750695 100644
--- a/src/inc/taosmsg.h
+++ b/src/inc/taosmsg.h
@@ -479,6 +479,7 @@ typedef struct {
   int32_t     tsLen;          // total length of ts comp block
   int32_t     tsNumOfBlocks;  // ts comp block numbers
   int32_t     tsOrder;        // ts comp block order
+  int32_t     numOfTags;      // number of tags columns involved
   SColumnInfo colList[];
 } SQueryTableMsg;
 
diff --git a/src/query/inc/queryExecutor.h b/src/query/inc/queryExecutor.h
index a9a9424a7c8e081c649f525d8c1330abf415cdcf..7887b25345660589f35a37a36915b47b3703bfbf 100644
--- a/src/query/inc/queryExecutor.h
+++ b/src/query/inc/queryExecutor.h
@@ -39,10 +39,10 @@ typedef int32_t (*__block_search_fn_t)(char* data, int32_t num, int64_t key, int
 
 typedef struct SSqlGroupbyExpr {
   int16_t     tableIndex;
+  SArray*     columnInfo;      // SArray<SColIndex>, group by columns information
   int16_t     numOfGroupCols;
-  SColIndex*  columnInfo;                 // group by columns information
-  int16_t     orderIndex;                 // order by column index
-  int16_t     orderType;                  // order by type: asc/desc
+  int16_t     orderIndex;      // order by column index
+  int16_t     orderType;       // order by type: asc/desc
 } SSqlGroupbyExpr;
 
 typedef struct SPosInfo {
@@ -116,6 +116,8 @@ typedef struct STableDataInfo {
 
 typedef struct SQuery {
   int16_t           numOfCols;
+  int16_t           numOfTags;
+  
   SOrderVal         order;
   STimeWindow       window;
   int64_t           intervalTime;
@@ -128,8 +130,9 @@ typedef struct SQuery {
   SLimitVal         limit;
   int32_t           rowSize;
   SSqlGroupbyExpr*  pGroupbyExpr;
-  SArithExprInfo* pSelectExpr;
+  SArithExprInfo*   pSelectExpr;
   SColumnInfo*      colList;
+  SColumnInfo*      tagColList;
   int32_t           numOfFilterCols;
   int64_t*          defaultVal;
   TSKEY             lastKey;
diff --git a/src/query/src/queryExecutor.c b/src/query/src/queryExecutor.c
index b2c814d101e8eee0f6176fccd4c9f152c49fa6d0..df282b9845a6c3c382074a2fb4c5f57554e95d39 100644
--- a/src/query/src/queryExecutor.c
+++ b/src/query/src/queryExecutor.c
@@ -289,7 +289,7 @@ bool isGroupbyNormalCol(SSqlGroupbyExpr *pGroupbyExpr) {
   }
 
   for (int32_t i = 0; i < pGroupbyExpr->numOfGroupCols; ++i) {
-    SColIndex *pColIndex = &pGroupbyExpr->columnInfo[i];
+    SColIndex *pColIndex = taosArrayGet(pGroupbyExpr->columnInfo, i);
     if (pColIndex->flag == TSDB_COL_NORMAL) {
       /*
        * make sure the normal column locates at the second position if tbname exists in group by clause
@@ -312,7 +312,7 @@ int16_t getGroupbyColumnType(SQuery *pQuery, SSqlGroupbyExpr *pGroupbyExpr) {
   int16_t type = TSDB_DATA_TYPE_NULL;
 
   for (int32_t i = 0; i < pGroupbyExpr->numOfGroupCols; ++i) {
-    SColIndex *pColIndex = &pGroupbyExpr->columnInfo[i];
+    SColIndex *pColIndex = taosArrayGet(pGroupbyExpr->columnInfo, i);
     if (pColIndex->flag == TSDB_COL_NORMAL) {
       colId = pColIndex->colId;
       break;
@@ -996,12 +996,13 @@ static UNUSED_FUNC char *getGroupbyColumnData(SQuery *pQuery, SData **data, int1
   SSqlGroupbyExpr *pGroupbyExpr = pQuery->pGroupbyExpr;
 
   for (int32_t k = 0; k < pGroupbyExpr->numOfGroupCols; ++k) {
-    if (pGroupbyExpr->columnInfo[k].flag == TSDB_COL_TAG) {
+    SColIndex* pColIndex = taosArrayGet(pGroupbyExpr->columnInfo, k);
+    if (pColIndex->flag == TSDB_COL_TAG) {
       continue;
     }
 
     int16_t colIndex = -1;
-    int32_t colId = pGroupbyExpr->columnInfo[k].colId;
+    int32_t colId = pColIndex->colId;
 
     for (int32_t i = 0; i < pQuery->numOfCols; ++i) {
       if (pQuery->colList[i].colId == colId) {
@@ -1378,9 +1379,17 @@ static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, int16_t order
     SSqlFuncMsg *pSqlFuncMsg = &pQuery->pSelectExpr[i].pBase;
 
     SQLFunctionCtx *pCtx = &pRuntimeEnv->pCtx[i];
-    pCtx->inputType = GET_COLUMN_TYPE(pQuery, i);
-    pCtx->inputBytes = GET_COLUMN_BYTES(pQuery, i);
-
+    SColIndex* pIndex = &pSqlFuncMsg->colInfo;
+    
+    int32_t index = pSqlFuncMsg->colInfo.colIndex;
+    if (TSDB_COL_IS_TAG(pIndex->flag)) {
+      pCtx->inputBytes = pQuery->tagColList[index].bytes;
+      pCtx->inputType = pQuery->tagColList[index].type;
+    } else {
+      pCtx->inputBytes = pQuery->colList[index].bytes;
+      pCtx->inputType = pQuery->colList[index].type;
+    }
+    
     pCtx->ptsOutputBuf = NULL;
 
     pCtx->outputBytes = pQuery->pSelectExpr[i].bytes;
@@ -4263,9 +4272,8 @@ static UNUSED_FUNC bool isGroupbyEachTable(SSqlGroupbyExpr *pGroupbyExpr, STable
   }
 
   for (int32_t i = 0; i < pGroupbyExpr->numOfGroupCols; ++i) {
-    SColIndex *pColIndex = &pGroupbyExpr->columnInfo[i];
+    SColIndex* pColIndex = taosArrayGet(pGroupbyExpr->columnInfo, i);
     if (pColIndex->flag == TSDB_COL_TAG) {
-      //      assert(pSidset->numOfTables == pSidset->numOfSubSet);
       return true;
     }
   }
@@ -5142,23 +5150,34 @@ static void stableQueryImpl(SQInfo *pQInfo) {
   sem_post(&pQInfo->dataReady);
 }
 
-static int32_t getColumnIndexInSource(SQueryTableMsg *pQueryMsg, SSqlFuncMsg *pExprMsg) {
+static int32_t getColumnIndexInSource(SQueryTableMsg *pQueryMsg, SSqlFuncMsg *pExprMsg, SColumnInfo* pTagCols) {
   int32_t j = 0;
-
-  while (j < pQueryMsg->numOfCols) {
-    if (pExprMsg->colInfo.colId == pQueryMsg->colList[j].colId) {
-      break;
+  
+  if (TSDB_COL_IS_TAG(pExprMsg->colInfo.flag)) {
+    while(j < pQueryMsg->numOfTags) {
+      if (pExprMsg->colInfo.colId == pTagCols[j].colId) {
+        return j;
+      }
+      
+      j += 1;
+    }
+    
+  } else {
+    while (j < pQueryMsg->numOfCols) {
+      if (pExprMsg->colInfo.colId == pQueryMsg->colList[j].colId) {
+        return j;
+      }
+    
+      j += 1;
     }
-
-    j += 1;
   }
 
-  return j;
+  assert(0);
 }
 
-bool vnodeValidateExprColumnInfo(SQueryTableMsg *pQueryMsg, SSqlFuncMsg *pExprMsg) {
-  int32_t j = getColumnIndexInSource(pQueryMsg, pExprMsg);
-  return j < pQueryMsg->numOfCols;
+bool validateExprColumnInfo(SQueryTableMsg *pQueryMsg, SSqlFuncMsg *pExprMsg, SColumnInfo* pTagCols) {
+  int32_t j = getColumnIndexInSource(pQueryMsg, pExprMsg, pTagCols);
+  return j < pQueryMsg->numOfCols || j < pQueryMsg->numOfTags;
 }
 
 static int32_t validateQueryMsg(SQueryTableMsg *pQueryMsg) {
@@ -5228,7 +5247,7 @@ static char *createTableIdList(SQueryTableMsg *pQueryMsg, char *pMsg, SArray **p
  * @return
  */
 static int32_t convertQueryMsg(SQueryTableMsg *pQueryMsg, SArray **pTableIdList, SSqlFuncMsg ***pExpr,
-                               char **tagCond, SColIndex **groupbyCols) {
+                               char **tagCond, SColIndex **groupbyCols, SColumnInfo** tagCols) {
   pQueryMsg->numOfTables = htonl(pQueryMsg->numOfTables);
 
   pQueryMsg->window.skey = htobe64(pQueryMsg->window.skey);
@@ -5250,6 +5269,7 @@ static int32_t convertQueryMsg(SQueryTableMsg *pQueryMsg, SArray **pTableIdList,
   pQueryMsg->tsLen = htonl(pQueryMsg->tsLen);
   pQueryMsg->tsNumOfBlocks = htonl(pQueryMsg->tsNumOfBlocks);
   pQueryMsg->tsOrder = htonl(pQueryMsg->tsOrder);
+  pQueryMsg->numOfTags = htonl(pQueryMsg->numOfTags);
 
   // query msg safety check
   if (validateQueryMsg(pQueryMsg) != 0) {
@@ -5333,9 +5353,9 @@ static int32_t convertQueryMsg(SQueryTableMsg *pQueryMsg, SArray **pTableIdList,
         return TSDB_CODE_INVALID_QUERY_MSG;
       }
     } else {
-      if (!vnodeValidateExprColumnInfo(pQueryMsg, pExprMsg)) {
-        return TSDB_CODE_INVALID_QUERY_MSG;
-      }
+//      if (!validateExprColumnInfo(pQueryMsg, pExprMsg)) {
+//        return TSDB_CODE_INVALID_QUERY_MSG;
+//      }
     }
 
     pExprMsg = (SSqlFuncMsg *)pMsg;
@@ -5387,6 +5407,21 @@ static int32_t convertQueryMsg(SQueryTableMsg *pQueryMsg, SArray **pTableIdList,
   if (pQueryMsg->tagCondLen > 0) {
     *tagCond = calloc(1, pQueryMsg->tagCondLen);
     memcpy(*tagCond, pMsg, pQueryMsg->tagCondLen);
+    pMsg += pQueryMsg->tagCondLen;
+  }
+  
+  if (pQueryMsg->numOfTags > 0) {
+    (*tagCols) = calloc(1, sizeof(SColumnInfo) * pQueryMsg->numOfTags);
+    for (int32_t i = 0; i < pQueryMsg->numOfTags; ++i) {
+      SColumnInfo* pTagCol = (SColumnInfo*) pMsg;
+  
+      pTagCol->colId = htons(pTagCol->colId);
+      pTagCol->bytes = htons(pTagCol->bytes);
+      pTagCol->type  = htons(pTagCol->type);
+      pTagCol->numOfFilters = 0;
+      
+      (*tagCols)[i] = *pTagCol;
+    }
   }
 
   qTrace("qmsg:%p query on %d table(s), qrange:%" PRId64 "-%" PRId64
@@ -5452,7 +5487,7 @@ static int32_t buildAirthmeticExprFromMsg(SArithExprInfo *pExpr, SQueryTableMsg
 }
 
 static int32_t createSqlFunctionExprFromMsg(SQueryTableMsg *pQueryMsg, SArithExprInfo **pSqlFuncExpr,
-                                            SSqlFuncMsg **pExprMsg) {
+                                            SSqlFuncMsg **pExprMsg, SColumnInfo* pTagCols) {
   *pSqlFuncExpr = NULL;
   int32_t code = TSDB_CODE_SUCCESS;
 
@@ -5483,10 +5518,10 @@ static int32_t createSqlFunctionExprFromMsg(SQueryTableMsg *pQueryMsg, SArithExp
       type = TSDB_DATA_TYPE_DOUBLE;
       bytes = tDataTypeDesc[type].nSize;
     } else {  // parse the normal column
-      int32_t j = getColumnIndexInSource(pQueryMsg, &pExprs[i].pBase);
+      int32_t j = getColumnIndexInSource(pQueryMsg, &pExprs[i].pBase, pTagCols);
       assert(j < pQueryMsg->numOfCols);
 
-      SColumnInfo *pCol = &pQueryMsg->colList[j];
+      SColumnInfo* pCol = (TSDB_COL_IS_TAG(pExprs[i].pBase.colInfo.flag))? &pTagCols[j]:&pQueryMsg->colList[j];
       type = pCol->type;
       bytes = pCol->bytes;
     }
@@ -5510,16 +5545,15 @@ static int32_t createSqlFunctionExprFromMsg(SQueryTableMsg *pQueryMsg, SArithExp
   for (int32_t i = 0; i < pQueryMsg->numOfOutput; ++i) {
     pExprs[i].pBase = *pExprMsg[i];
     int16_t functId = pExprs[i].pBase.functionId;
+    
     if (functId == TSDB_FUNC_TOP || functId == TSDB_FUNC_BOTTOM) {
-      int32_t j = getColumnIndexInSource(pQueryMsg, &pExprs[i].pBase);
+      int32_t j = getColumnIndexInSource(pQueryMsg, &pExprs[i].pBase, pTagCols);
       assert(j < pQueryMsg->numOfCols);
 
       SColumnInfo *pCol = &pQueryMsg->colList[j];
-      int16_t      type = pCol->type;
-      int16_t      bytes = pCol->bytes;
 
       int32_t ret =
-          getResultDataInfo(type, bytes, pExprs[i].pBase.functionId, pExprs[i].pBase.arg[0].argValue.i64,
+          getResultDataInfo(pCol->type, pCol->bytes, functId, pExprs[i].pBase.arg[0].argValue.i64,
                             &pExprs[i].type, &pExprs[i].bytes, &pExprs[i].interResBytes, tagLen, isSuperTable);
       assert(ret == TSDB_CODE_SUCCESS);
     }
@@ -5547,7 +5581,11 @@ static SSqlGroupbyExpr *createGroupbyExprFromMsg(SQueryTableMsg *pQueryMsg, SCol
   pGroupbyExpr->orderType = pQueryMsg->orderType;
   pGroupbyExpr->orderIndex = pQueryMsg->orderByIdx;
 
-  pGroupbyExpr->columnInfo = pColIndex;
+  pGroupbyExpr->columnInfo = taosArrayInit(pQueryMsg->numOfGroupCols, sizeof(SColIndex));
+  for(int32_t i = 0; i < pQueryMsg->numOfGroupCols; ++i) {
+    taosArrayPush(pGroupbyExpr->columnInfo, &pColIndex[i]);
+  }
+  
   return pGroupbyExpr;
 }
 
@@ -5646,17 +5684,26 @@ static void doUpdateExprColumnIndex(SQuery *pQuery) {
     }
 
     SColIndex *pColIndexEx = &pSqlExprMsg->colInfo;
-    for (int32_t f = 0; f < pQuery->numOfCols; ++f) {
-      if (pColIndexEx->colId == pQuery->colList[f].colId) {
-        pColIndexEx->colIndex = f;
-        break;
+    if (!TSDB_COL_IS_TAG(pColIndexEx->flag)) {
+      for (int32_t f = 0; f < pQuery->numOfCols; ++f) {
+        if (pColIndexEx->colId == pQuery->colList[f].colId) {
+          pColIndexEx->colIndex = f;
+          break;
+        }
+      }
+    } else {
+      for (int32_t f = 0; f < pQuery->numOfTags; ++f) {
+        if (pColIndexEx->colId == pQuery->tagColList[f].colId) {
+          pColIndexEx->colIndex = f;
+          break;
+        }
       }
     }
   }
 }
 
 static SQInfo *createQInfoImpl(SQueryTableMsg *pQueryMsg, SSqlGroupbyExpr *pGroupbyExpr, SArithExprInfo *pExprs,
-                               STableGroupInfo *groupInfo) {
+                               STableGroupInfo *groupInfo, SColumnInfo* pTagCols) {
   SQInfo *pQInfo = (SQInfo *)calloc(1, sizeof(SQInfo));
   if (pQInfo == NULL) {
     return NULL;
@@ -5680,8 +5727,9 @@ static SQInfo *createQInfoImpl(SQueryTableMsg *pQueryMsg, SSqlGroupbyExpr *pGrou
   pQuery->slidingTime     = pQueryMsg->slidingTime;
   pQuery->slidingTimeUnit = pQueryMsg->slidingTimeUnit;
   pQuery->interpoType     = pQueryMsg->interpoType;
+  pQuery->numOfTags       = pQueryMsg->numOfTags;
 
-  pQuery->colList = calloc(1, sizeof(SSingleColumnFilterInfo) * numOfCols);
+  pQuery->colList = calloc(numOfCols, sizeof(SSingleColumnFilterInfo));
   if (pQuery->colList == NULL) {
     goto _cleanup;
   }
@@ -5692,7 +5740,16 @@ static SQInfo *createQInfoImpl(SQueryTableMsg *pQueryMsg, SSqlGroupbyExpr *pGrou
     SColumnInfo *pColInfo = &pQuery->colList[i];
     pColInfo->filters = tscFilterInfoClone(pQueryMsg->colList[i].filters, pColInfo->numOfFilters);
   }
-
+  
+  pQuery->tagColList = calloc(pQueryMsg->numOfTags, sizeof(SColumnInfo));
+  if (pQuery->tagColList == NULL) {
+    goto _cleanup;
+  }
+  
+  for(int16_t i = 0; i < pQuery->numOfTags; ++i) {
+    pQuery->tagColList[i] = pTagCols[i];
+  }
+  
   // calculate the result row size
   for (int16_t col = 0; col < numOfOutput; ++col) {
     assert(pExprs[col].bytes > 0);
@@ -5743,8 +5800,7 @@ static SQInfo *createQInfoImpl(SQueryTableMsg *pQueryMsg, SSqlGroupbyExpr *pGrou
 
   pQuery->pos = -1;
 
-  pQuery->window.skey = pQueryMsg->window.skey;
-  pQuery->window.ekey = pQueryMsg->window.ekey;
+  pQuery->window = pQueryMsg->window;
   pQuery->lastKey = pQuery->window.skey;
 
   if (sem_init(&pQInfo->dataReady, 0, 0) != 0) {
@@ -5955,12 +6011,14 @@ int32_t qCreateQueryInfo(void *tsdb, SQueryTableMsg *pQueryMsg, qinfo_t *pQInfo)
 
   int32_t code = TSDB_CODE_SUCCESS;
 
-  char *            tagCond = NULL;
-  SArray *          pTableIdList = NULL;
+  char *        tagCond = NULL;
+  SArray *      pTableIdList = NULL;
   SSqlFuncMsg **pExprMsg = NULL;
-  SColIndex *       pGroupColIndex = NULL;
+  SColIndex *   pGroupColIndex = NULL;
+  SColumnInfo*  pTagColumnInfo = NULL;
 
-  if ((code = convertQueryMsg(pQueryMsg, &pTableIdList, &pExprMsg, &tagCond, &pGroupColIndex)) != TSDB_CODE_SUCCESS) {
+  if ((code = convertQueryMsg(pQueryMsg, &pTableIdList, &pExprMsg, &tagCond,
+      &pGroupColIndex, &pTagColumnInfo)) != TSDB_CODE_SUCCESS) {
     return code;
   }
 
@@ -5977,7 +6035,7 @@ int32_t qCreateQueryInfo(void *tsdb, SQueryTableMsg *pQueryMsg, qinfo_t *pQInfo)
   }
 
   SArithExprInfo *pExprs = NULL;
-  if ((code = createSqlFunctionExprFromMsg(pQueryMsg, &pExprs, pExprMsg)) != TSDB_CODE_SUCCESS) {
+  if ((code = createSqlFunctionExprFromMsg(pQueryMsg, &pExprs, pExprMsg, pTagColumnInfo)) != TSDB_CODE_SUCCESS) {
     goto _query_over;
   }
 
@@ -6010,7 +6068,7 @@ int32_t qCreateQueryInfo(void *tsdb, SQueryTableMsg *pQueryMsg, qinfo_t *pQInfo)
     }
   }
 
-  (*pQInfo) = createQInfoImpl(pQueryMsg, pGroupbyExpr, pExprs, &groupInfo);
+  (*pQInfo) = createQInfoImpl(pQueryMsg, pGroupbyExpr, pExprs, &groupInfo, pTagColumnInfo);
   if ((*pQInfo) == NULL) {
     code = TSDB_CODE_SERV_OUT_OF_MEMORY;
   }