[td-2819] refactor codes and fix memory leak

src/client/src/tscServer.c

@@ -692,6 +692,54 @@ static char *doSerializeTableInfo(SQueryTableMsg* pQueryMsg, SSqlObj *pSql, char
   return pMsg;
 }
 
+static int32_t serializeSqlExpr(SSqlExpr* pExpr, STableMetaInfo* pTableMetaInfo, char** pMsg, void* addr) {
+  STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
+
+  // the queried table has been removed and a new table with the same name has already been created already
+  // return error msg
+  if (pExpr->uid != pTableMeta->id.uid) {
+    tscError("%p table has already been destroyed", addr);
+    return TSDB_CODE_TSC_INVALID_TABLE_NAME;
+  }
+
+  if (!tscValidateColumnId(pTableMetaInfo, pExpr->colInfo.colId, pExpr->numOfParams)) {
+    tscError("%p table schema is not matched with parsed sql", addr);
+    return TSDB_CODE_TSC_INVALID_SQL;
+  }
+
+  assert(pExpr->resColId < 0);
+  SSqlExpr* pSqlExpr = (SSqlExpr *)(*pMsg);
+
+  SColIndex* pIndex = &pSqlExpr->colInfo;
+  
+  pIndex->colId         = htons(pExpr->colInfo.colId);
+  pIndex->colIndex      = htons(pExpr->colInfo.colIndex);
+  pIndex->flag          = htons(pExpr->colInfo.flag);
+  pSqlExpr->uid         = htobe64(pExpr->uid);
+  pSqlExpr->colType     = htons(pExpr->colType);
+  pSqlExpr->colBytes    = htons(pExpr->colBytes);
+  pSqlExpr->resType     = htons(pExpr->resType);
+  pSqlExpr->resBytes    = htons(pExpr->resBytes);
+  pSqlExpr->functionId  = htons(pExpr->functionId);
+  pSqlExpr->numOfParams = htons(pExpr->numOfParams);
+  pSqlExpr->resColId    = htons(pExpr->resColId);
+
+  (*pMsg) += sizeof(SSqlExpr);
+  for (int32_t j = 0; j < pExpr->numOfParams; ++j) { // todo add log
+    pSqlExpr->param[j].nType = htons((uint16_t)pExpr->param[j].nType);
+    pSqlExpr->param[j].nLen = htons(pExpr->param[j].nLen);
+
+    if (pExpr->param[j].nType == TSDB_DATA_TYPE_BINARY) {
+      memcpy((*pMsg), pExpr->param[j].pz, pExpr->param[j].nLen);
+      (*pMsg) += pExpr->param[j].nLen;
+    } else {
+      pSqlExpr->param[j].i64 = htobe64(pExpr->param[j].i64);
+    }
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
 int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SSqlCmd *pCmd = &pSql->cmd;
 
@@ -703,15 +751,16 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   }
   
   SQueryInfo *pQueryInfo = tscGetActiveQueryInfo(pCmd);
+
   SQueryAttr query = {0};
   tscCreateQueryFromQueryInfo(pQueryInfo, &query, pSql);
+
   SArray* tableScanOperator = createTableScanPlan(&query);
   SArray* queryOperator = createExecOperatorPlan(&query);
 
   STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
   STableMeta * pTableMeta = pTableMetaInfo->pTableMeta;
 
-  {
   SQueryTableMsg *pQueryMsg = (SQueryTableMsg *)pCmd->payload;
   tstrncpy(pQueryMsg->version, version, tListLen(pQueryMsg->version));
 
@@ -813,94 +862,17 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
     }
   }
 
-    SSqlExpr *pSqlExpr = (SSqlExpr *)pMsg;
-
   for (int32_t i = 0; i < query.numOfOutput; ++i) {
-      SSqlExpr *pExpr = &query.pExpr1[i].base;
-
-      // the queried table has been removed and a new table with the same name has already been created already
-      // return error msg
-      if (pExpr->uid != pTableMeta->id.uid) {
-        tscError("%p table has already been destroyed", pSql);
-        return TSDB_CODE_TSC_INVALID_TABLE_NAME;
-      }
-
-      if (!tscValidateColumnId(pTableMetaInfo, pExpr->colInfo.colId, pExpr->numOfParams)) {
-        tscError("%p table schema is not matched with parsed sql", pSql);
-        return TSDB_CODE_TSC_INVALID_SQL;
-      }
-
-      assert(pExpr->resColId < 0);
-
-      pSqlExpr->colInfo.colId    = htons(pExpr->colInfo.colId);
-      pSqlExpr->colInfo.colIndex = htons(pExpr->colInfo.colIndex);
-      pSqlExpr->colInfo.flag     = htons(pExpr->colInfo.flag);
-      pSqlExpr->uid              = htobe64(pExpr->uid);
-      pSqlExpr->colType          = htons(pExpr->colType);
-      pSqlExpr->colBytes         = htons(pExpr->colBytes);
-      pSqlExpr->resType          = htons(pExpr->resType);
-      pSqlExpr->resBytes         = htons(pExpr->resBytes);
-      pSqlExpr->functionId       = htons(pExpr->functionId);
-      pSqlExpr->numOfParams      = htons(pExpr->numOfParams);
-      pSqlExpr->resColId         = htons(pExpr->resColId);
-
-      pMsg += sizeof(SSqlExpr);
-      for (int32_t j = 0; j < pExpr->numOfParams; ++j) { // todo add log
-        pSqlExpr->param[j].nType = htons((uint16_t)pExpr->param[j].nType);
-        pSqlExpr->param[j].nLen = htons(pExpr->param[j].nLen);
-
-        if (pExpr->param[j].nType == TSDB_DATA_TYPE_BINARY) {
-          memcpy(pMsg, pExpr->param[j].pz, pExpr->param[j].nLen);
-          pMsg += pExpr->param[j].nLen;
-        } else {
-          pSqlExpr->param[j].i64 = htobe64(pExpr->param[j].i64);
+    int32_t code = serializeSqlExpr(&query.pExpr1[i].base, pTableMetaInfo, &pMsg, pSql);
+    if (code != TSDB_CODE_SUCCESS) {
+      return code;
     }
   }
 
-      pSqlExpr = (SSqlExpr *)pMsg;
-    }
-
-    if (query.numOfExpr2 > 0) {
   for (int32_t i = 0; i < query.numOfExpr2; ++i) {
-        SSqlExpr *pExpr = &query.pExpr2[i].base;
-
-        // the queried table has been removed and a new table with the same name has already been created already
-        // return error msg
-        if (pExpr->uid != pTableMeta->id.uid) {
-          tscError("%p table has already been destroyed", pSql);
-          return TSDB_CODE_TSC_INVALID_TABLE_NAME;
-        }
-
-        assert(pExpr->resColId < 0);
-
-        pSqlExpr->colInfo.colId = htons(pExpr->colInfo.colId);
-        pSqlExpr->colInfo.colIndex = htons(pExpr->colInfo.colIndex);
-        pSqlExpr->colInfo.flag = htons(pExpr->colInfo.flag);
-        pSqlExpr->uid = htobe64(pExpr->uid);
-
-        pSqlExpr->colType  = htons(pExpr->colType);
-        pSqlExpr->colBytes = htons(pExpr->colBytes);
-        pSqlExpr->resType  = htons(pExpr->resType);
-        pSqlExpr->resBytes = htons(pExpr->resBytes);
-
-        pSqlExpr->functionId  = htons(pExpr->functionId);
-        pSqlExpr->numOfParams = htons(pExpr->numOfParams);
-        pSqlExpr->resColId = htons(pExpr->resColId);
-        pMsg += sizeof(SSqlExpr);
-
-        for (int32_t j = 0; j < pExpr->numOfParams; ++j) {  // todo add log
-          pSqlExpr->param[j].nType = htons((uint16_t)pExpr->param[j].nType);
-          pSqlExpr->param[j].nLen = htons(pExpr->param[j].nLen);
-
-          if (pExpr->param[j].nType == TSDB_DATA_TYPE_BINARY) {
-            memcpy(pMsg, pExpr->param[j].pz, pExpr->param[j].nLen);
-            pMsg += pExpr->param[j].nLen;
-          } else {
-            pSqlExpr->param[j].i64 = htobe64(pExpr->param[j].i64);
-          }
-        }
-
-        pSqlExpr = (SSqlExpr *)pMsg;
+    int32_t code = serializeSqlExpr(&query.pExpr2[i].base, pTableMetaInfo, &pMsg, pSql);
+    if (code != TSDB_CODE_SUCCESS) {
+      return code;
     }
   }
 
@@ -1013,362 +985,11 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   pQueryMsg->head.contLen = htonl(msgLen);
   assert(msgLen + minMsgSize() <= (int32_t)pCmd->allocSize);
 
-    return TSDB_CODE_SUCCESS;
-  }
-/*
-  SQueryTableMsg *pQueryMsg = (SQueryTableMsg *)pCmd->payload;
-  tstrncpy(pQueryMsg->version, version, tListLen(pQueryMsg->version));
-
-  int32_t numOfTags = (int32_t)taosArrayGetSize(pTableMetaInfo->tagColList);
-  int32_t sqlLen = (int32_t) strlen(pSql->sqlstr);
-
-  if (pQueryInfo->order.order == TSDB_ORDER_ASC) {
-    pQueryMsg->window.skey = htobe64(pQueryInfo->window.skey);
-    pQueryMsg->window.ekey = htobe64(pQueryInfo->window.ekey);
-  } else {
-    pQueryMsg->window.skey = htobe64(pQueryInfo->window.ekey);
-    pQueryMsg->window.ekey = htobe64(pQueryInfo->window.skey);
-  }
-
-  pQueryMsg->order          = htons(pQueryInfo->order.order);
-  pQueryMsg->orderColId     = htons(pQueryInfo->order.orderColId);
-  pQueryMsg->fillType       = htons(pQueryInfo->fillType);
-  pQueryMsg->limit          = htobe64(pQueryInfo->limit.limit);
-  pQueryMsg->offset         = htobe64(pQueryInfo->limit.offset);
-  pQueryMsg->numOfCols      = htons((int16_t)taosArrayGetSize(pQueryInfo->colList));
-  pQueryMsg->interval.interval = htobe64(pQueryInfo->interval.interval);
-  pQueryMsg->interval.sliding  = htobe64(pQueryInfo->interval.sliding);
-  pQueryMsg->interval.offset   = htobe64(pQueryInfo->interval.offset);
-  pQueryMsg->interval.intervalUnit = pQueryInfo->interval.intervalUnit;
-  pQueryMsg->interval.slidingUnit  = pQueryInfo->interval.slidingUnit;
-  pQueryMsg->interval.offsetUnit   = pQueryInfo->interval.offsetUnit;
-  pQueryMsg->numOfGroupCols = htons(pQueryInfo->groupbyExpr.numOfGroupCols);
-  pQueryMsg->tagNameRelType = htons(pQueryInfo->tagCond.relType);
-  pQueryMsg->tbnameCondLen  = htonl(pQueryInfo->tagCond.tbnameCond.len);
-  pQueryMsg->numOfTags      = htonl(numOfTags);
-  pQueryMsg->queryType      = htonl(pQueryInfo->type);
-  pQueryMsg->vgroupLimit    = htobe64(pQueryInfo->vgroupLimit);
-  pQueryMsg->sqlstrLen      = htonl(sqlLen);
-  pQueryMsg->prevResultLen  = htonl(pQueryInfo->bufLen);
-  pQueryMsg->sw.gap         = htobe64(pQueryInfo->sessionWindow.gap);
-  pQueryMsg->sw.primaryColId = htonl(PRIMARYKEY_TIMESTAMP_COL_INDEX);
-
-  size_t numOfOutput = tscSqlExprNumOfExprs(pQueryInfo);
-  pQueryMsg->numOfOutput = htons((int16_t)numOfOutput);  // this is the stage one output column number
-
-  // set column list ids
-  size_t numOfCols = taosArrayGetSize(pQueryInfo->colList);
-  char *pMsg = (char *)(pQueryMsg->colList) + numOfCols * sizeof(SColumnInfo);
-  SSchema *pSchema = tscGetTableSchema(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 >= tscGetNumOfColumns(pTableMeta) || !isValidDataType(pColSchema->type)) {
-      char n[TSDB_TABLE_FNAME_LEN] = {0};
-      tNameExtractFullName(&pTableMetaInfo->name, n);
-
-      tscError("%p tid:%d uid:%" PRIu64" id:%s, column index out of range, numOfColumns:%d, index:%d, column name:%s",
-          pSql, pTableMeta->id.tid, pTableMeta->id.uid, n, tscGetNumOfColumns(pTableMeta), pCol->colIndex.columnIndex,
-               pColSchema->name);
-      return TSDB_CODE_TSC_INVALID_SQL;
-    }
-
-    pQueryMsg->colList[i].colId = htons(pCol->info.colId);
-    pQueryMsg->colList[i].bytes = htons(pCol->info.bytes);
-    pQueryMsg->colList[i].type  = htons(pCol->info.type);
-    pQueryMsg->colList[i].numOfFilters = htons(pCol->info.numOfFilters);
-
-    // append the filter information after the basic column information
-    for (int32_t f = 0; f < pCol->info.numOfFilters; ++f) {
-      SColumnFilterInfo *pColFilter = &pCol->info.filterInfo[f];
-
-      SColumnFilterInfo *pFilterMsg = (SColumnFilterInfo *)pMsg;
-      pFilterMsg->filterstr = htons(pColFilter->filterstr);
-
-      pMsg += sizeof(SColumnFilterInfo);
-
-      if (pColFilter->filterstr) {
-        pFilterMsg->len = htobe64(pColFilter->len);
-        memcpy(pMsg, (void *)pColFilter->pz, (size_t)(pColFilter->len + 1));
-        pMsg += (pColFilter->len + 1);  // append the additional filter binary info
-      } else {
-        pFilterMsg->lowerBndi = htobe64(pColFilter->lowerBndi);
-        pFilterMsg->upperBndi = htobe64(pColFilter->upperBndi);
-      }
-
-      pFilterMsg->lowerRelOptr = htons(pColFilter->lowerRelOptr);
-      pFilterMsg->upperRelOptr = htons(pColFilter->upperRelOptr);
-
-      if (pColFilter->lowerRelOptr == TSDB_RELATION_INVALID && pColFilter->upperRelOptr == TSDB_RELATION_INVALID) {
-        tscError("invalid filter info");
-        return TSDB_CODE_TSC_INVALID_SQL;
-      }
-    }
-  }
-
-  SSqlExpr *pSqlExpr = (SSqlExpr *)pMsg;
-
-  for (int32_t i = 0; i < tscSqlExprNumOfExprs(pQueryInfo); ++i) {
-    SExprInfo *pExpr = tscSqlExprGet(pQueryInfo, i);
-
-    // the queried table has been removed and a new table with the same name has already been created already
-    // return error msg
-    if (pExpr->base.uid != pTableMeta->id.uid) {
-      tscError("%p table has already been destroyed", pSql);
-      return TSDB_CODE_TSC_INVALID_TABLE_NAME;
-    }
-
-    if (!tscValidateColumnId(pTableMetaInfo, pExpr->base.colInfo.colId, pExpr->base.numOfParams)) {
-      tscError("%p table schema is not matched with parsed sql", pSql);
-      return TSDB_CODE_TSC_INVALID_SQL;
-    }
-
-    assert(pExpr->base.resColId < 0);
-
-    pSqlExpr->colInfo.colId    = htons(pExpr->base.colInfo.colId);
-    pSqlExpr->colInfo.colIndex = htons(pExpr->base.colInfo.colIndex);
-    pSqlExpr->colInfo.flag     = htons(pExpr->base.colInfo.flag);
-
-    pSqlExpr->colType  = htons(pExpr->base.colType);
-    pSqlExpr->colBytes = htons(pExpr->base.colBytes);
-
-    if (TSDB_COL_IS_UD_COL(pExpr->base.colInfo.flag) || pExpr->base.colInfo.colId == TSDB_TBNAME_COLUMN_INDEX) {
-      pSqlExpr->resType  = htons(pExpr->base.resType);
-      pSqlExpr->resBytes = htons(pExpr->base.resBytes);
-    } else if (pExpr->base.colInfo.colId == TSDB_BLOCK_DIST_COLUMN_INDEX) {
-      SSchema s = tGetBlockDistColumnSchema();
-
-      pSqlExpr->resType = htons(s.type);
-      pSqlExpr->resBytes = htons(s.bytes);
-    } else {
-      SSchema* s = tscGetColumnSchemaById(pTableMeta, pExpr->base.colInfo.colId);
-      pSqlExpr->resType  = htons(s->type);
-      pSqlExpr->resBytes = htons(s->bytes);
-    }
-
-    pSqlExpr->functionId  = htons(pExpr->base.functionId);
-    pSqlExpr->numOfParams = htons(pExpr->base.numOfParams);
-    pSqlExpr->resColId    = htons(pExpr->base.resColId);
-    pMsg += sizeof(SSqlExpr);
-
-    for (int32_t j = 0; j < pExpr->base.numOfParams; ++j) { // todo add log
-      pSqlExpr->param[j].nType = htons((uint16_t)pExpr->base.param[j].nType);
-      pSqlExpr->param[j].nLen = htons(pExpr->base.param[j].nLen);
-
-      if (pExpr->base.param[j].nType == TSDB_DATA_TYPE_BINARY) {
-        memcpy(pMsg, pExpr->base.param[j].pz, pExpr->base.param[j].nLen);
-        pMsg += pExpr->base.param[j].nLen;
-      } else {
-        pSqlExpr->param[j].i64 = htobe64(pExpr->base.param[j].i64);
-      }
-    }
-
-    pSqlExpr = (SSqlExpr *)pMsg;
-  }
-
-  size_t output = tscNumOfFields(pQueryInfo);
-
-  if (tscIsSecondStageQuery(pQueryInfo)) {
-    pQueryMsg->secondStageOutput = htonl((int32_t) output);
-
-    SSqlExpr *pExpr1 = (SSqlExpr *)pMsg;
-
-    for (int32_t i = 0; i < output; ++i) {
-      SInternalField* pField = tscFieldInfoGetInternalField(&pQueryInfo->fieldsInfo, i);
-      SExprInfo *pExpr = pField->pExpr;
-
-      // this should be switched to projection query
-      if (pExpr->pExpr == NULL) {
-        // the queried table has been removed and a new table with the same name has already been created already
-        // return error msg
-        if (pExpr->base.uid != pTableMeta->id.uid) {
-          tscError("%p table has already been destroyed", pSql);
-          return TSDB_CODE_TSC_INVALID_TABLE_NAME;
-        }
-
-        if (!tscValidateColumnId(pTableMetaInfo, pExpr->base.colInfo.colId, pExpr->base.numOfParams)) {
-          tscError("%p table schema is not matched with parsed sql", pSql);
-          return TSDB_CODE_TSC_INVALID_SQL;
-        }
-
-        pExpr1->numOfParams = 0;  // no params for projection query
-        pExpr1->functionId  = htons(TSDB_FUNC_PRJ);
-        pExpr1->colInfo.colId = htons(pExpr->base.resColId);
-        pExpr1->colInfo.flag = htons(TSDB_COL_NORMAL);
-        pExpr1->colType = htons(pExpr->base.resType);
-        pExpr1->colBytes = htons(pExpr->base.resBytes);
-
-        bool assign = false;
-        for (int32_t f = 0; f < tscSqlExprNumOfExprs(pQueryInfo); ++f) {
-          SExprInfo *pe = tscSqlExprGet(pQueryInfo, f);
-          if (pe == pExpr) {
-            pExpr1->colInfo.colIndex = htons(f);
-            pExpr1->resType = htons(pe->base.resType);
-            pExpr1->resBytes = htons(pe->base.resBytes);
-            assign = true;
-            break;
-          }
-        }
-
-        assert(assign);
-        pMsg += sizeof(SSqlExpr);
-        pExpr1 = (SSqlExpr *)pMsg;
-      } else {
-        assert(pField->pExpr != NULL);
-        SExprInfo* pExprInfo = pField->pExpr;
-
-        pExpr1->colInfo.colId = htons(pExprInfo->base.colInfo.colId);
-        pExpr1->colType = htons(pExprInfo->base.colType);
-        pExpr1->colBytes = htons(pExprInfo->base.colBytes);
-        pExpr1->resBytes = htons(sizeof(double));
-        pExpr1->resType = htons(TSDB_DATA_TYPE_DOUBLE);
-
-        pExpr1->functionId  = htons(pExprInfo->base.functionId);
-        pExpr1->numOfParams = htons(pExprInfo->base.numOfParams);
-        pMsg += sizeof(SSqlExpr);
-
-        for (int32_t j = 0; j < pExprInfo->base.numOfParams; ++j) {
-          // todo add log
-          pExpr1->param[j].nType = htons((uint16_t)pExprInfo->base.param[j].nType);
-          pExpr1->param[j].nLen = htons(pExprInfo->base.param[j].nLen);
-
-          if (pExprInfo->base.param[j].nType == TSDB_DATA_TYPE_BINARY) {
-            memcpy(pMsg, pExprInfo->base.param[j].pz, pExprInfo->base.param[j].nLen);
-            pMsg += pExprInfo->base.param[j].nLen;
-          } else {
-            pExpr1->param[j].i64 = htobe64(pExprInfo->base.param[j].i64);
-          }
-        }
-
-        pExpr1 = (SSqlExpr *)pMsg;
-      }
-    }
-  } else {
-    pQueryMsg->secondStageOutput = 0;
-  }
-
-  // serialize the table info (sid, uid, tags)
-  pMsg = doSerializeTableInfo(pQueryMsg, pSql, pMsg);
-  
-  SSqlGroupbyExpr *pGroupbyExpr = &pQueryInfo->groupbyExpr;
-  if (pGroupbyExpr->numOfGroupCols > 0) {
-    pQueryMsg->orderByIdx = htons(pGroupbyExpr->orderIndex);
-    pQueryMsg->orderType = htons(pGroupbyExpr->orderType);
-
-    for (int32_t j = 0; j < pGroupbyExpr->numOfGroupCols; ++j) {
-      SColIndex* pCol = taosArrayGet(pGroupbyExpr->columnInfo, j);
-  
-      *((int16_t *)pMsg) = htons(pCol->colId);
-      pMsg += sizeof(pCol->colId);
-
-      *((int16_t *)pMsg) += htons(pCol->colIndex);
-      pMsg += sizeof(pCol->colIndex);
-
-      *((int16_t *)pMsg) += htons(pCol->flag);
-      pMsg += sizeof(pCol->flag);
-      
-      memcpy(pMsg, pCol->name, tListLen(pCol->name));
-      pMsg += tListLen(pCol->name);
-    }
-  }
-
-  if (pQueryInfo->fillType != TSDB_FILL_NONE) {
-    for (int32_t i = 0; i < tscSqlExprNumOfExprs(pQueryInfo); ++i) {
-      *((int64_t *)pMsg) = htobe64(pQueryInfo->fillVal[i]);
-      pMsg += sizeof(pQueryInfo->fillVal[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(pTableMetaInfo->tagColList, i);
-      SSchema *pColSchema = &pSchema[pCol->colIndex.columnIndex];
-
-      if ((pCol->colIndex.columnIndex >= numOfTagColumns || pCol->colIndex.columnIndex < -1) ||
-          (!isValidDataType(pColSchema->type))) {
-        char n[TSDB_TABLE_FNAME_LEN] = {0};
-        tNameExtractFullName(&pTableMetaInfo->name, n);
-
-        tscError("%p tid:%d uid:%" PRIu64 " id:%s, tag index out of range, totalCols:%d, numOfTags:%d, index:%d, column name:%s",
-                 pSql, pTableMeta->id.tid, pTableMeta->id.uid, n, total, numOfTagColumns, pCol->colIndex.columnIndex, pColSchema->name);
-
-        return TSDB_CODE_TSC_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);
-    }
-  }
-
-  // serialize tag column query condition
-  if (pQueryInfo->tagCond.pCond != NULL && taosArrayGetSize(pQueryInfo->tagCond.pCond) > 0) {
-    STagCond* pTagCond = &pQueryInfo->tagCond;
-    
-    SCond *pCond = tsGetSTableQueryCond(pTagCond, pTableMeta->id.uid);
-    if (pCond != NULL && pCond->cond != NULL) {
-      pQueryMsg->tagCondLen = htons(pCond->len);
-      memcpy(pMsg, pCond->cond, pCond->len);
-      
-      pMsg += pCond->len;
-    }
-  }
-
-  if (pQueryInfo->bufLen > 0) {
-    memcpy(pMsg, pQueryInfo->buf, pQueryInfo->bufLen);
-    pMsg += pQueryInfo->bufLen;
-  }
-
-  SCond* pCond = &pQueryInfo->tagCond.tbnameCond;
-  if (pCond->len > 0) {
-    strncpy(pMsg, pCond->cond, pCond->len);
-    pMsg += pCond->len;
-  }
-
-  // compressed ts block
-  pQueryMsg->tsBuf.tsOffset = htonl((int32_t)(pMsg - pCmd->payload));
-
-  if (pQueryInfo->tsBuf != NULL) {
-    // note: here used the index instead of actual vnode id.
-    int32_t vnodeIndex = pTableMetaInfo->vgroupIndex;
-    int32_t code = dumpFileBlockByGroupId(pQueryInfo->tsBuf, vnodeIndex, pMsg, &pQueryMsg->tsBuf.tsLen, &pQueryMsg->tsBuf.tsNumOfBlocks);
-    if (code != TSDB_CODE_SUCCESS) {
-      return code;
-    }
+  freeQueryAttr(&query);
+  taosArrayDestroy(tableScanOperator);
+  taosArrayDestroy(queryOperator);
 
-    pMsg += pQueryMsg->tsBuf.tsLen;
-
-    pQueryMsg->tsBuf.tsOrder = htonl(pQueryInfo->tsBuf->tsOrder);
-    pQueryMsg->tsBuf.tsLen   = htonl(pQueryMsg->tsBuf.tsLen);
-    pQueryMsg->tsBuf.tsNumOfBlocks = htonl(pQueryMsg->tsBuf.tsNumOfBlocks);
-  }
-
-  memcpy(pMsg, pSql->sqlstr, sqlLen);
-  pMsg += sqlLen;
-
-  int32_t msgLen = (int32_t)(pMsg - pCmd->payload);
-
-  tscDebug("%p msg built success, len:%d bytes", pSql, msgLen);
-  pCmd->payloadLen = msgLen;
-  pSql->cmd.msgType = TSDB_MSG_TYPE_QUERY;
-  
-  pQueryMsg->head.contLen = htonl(msgLen);
-  assert(msgLen + minMsgSize() <= (int32_t)pCmd->allocSize);
-
-  return TSDB_CODE_SUCCESS;*/
+  return TSDB_CODE_SUCCESS;
 }
 
 int32_t tscBuildCreateDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) {

src/client/src/tscUtil.c

@@ -2027,6 +2027,9 @@ static void freeQueryInfoImpl(SQueryInfo* pQueryInfo) {
 
   tfree(pQueryInfo->fillVal);
   tfree(pQueryInfo->buf);
+
+  taosArrayDestroy(pQueryInfo->pUpstream);
+  taosArrayDestroy(pQueryInfo->pDownstream);
 }
 
 void tscClearSubqueryInfo(SSqlCmd* pCmd) {

src/query/inc/qExecutor.h

@@ -467,6 +467,7 @@ size_t getResultSize(SQInfo *pQInfo, int64_t *numOfRows);
 void setQueryKilled(SQInfo *pQInfo);
 void queryCostStatis(SQInfo *pQInfo);
 void freeQInfo(SQInfo *pQInfo);
+void freeQueryAttr(SQueryAttr *pQuery);
 
 int32_t getMaximumIdleDurationSec();
 

src/query/src/qExecutor.c

@@ -6486,13 +6486,13 @@ void freeQInfo(SQInfo *pQInfo) {
     }
   }
 
+  tsdbDestroyTableGroup(&pQueryAttr->tableGroupInfo);
+
   doDestroyTableQueryInfo(&pRuntimeEnv->tableqinfoGroupInfo);
 
   tfree(pQInfo->pBuf);
   tfree(pQInfo->sql);
 
-  tsdbDestroyTableGroup(&pQueryAttr->tableGroupInfo);
-
   taosArrayDestroy(pRuntimeEnv->groupResInfo.pRows);
   pQInfo->signature = 0;
 
@@ -6639,3 +6639,38 @@ void releaseQueryBuf(size_t numOfTables) {
   // restore value is not enough buffer available
   atomic_add_fetch_64(&tsQueryBufferSizeBytes, t);
 }
+
+void freeQueryAttr(SQueryAttr* pQueryAttr) {
+  if (pQueryAttr != NULL) {
+    if (pQueryAttr->fillVal != NULL) {
+      tfree(pQueryAttr->fillVal);
+    }
+
+    for (int32_t i = 0; i < pQueryAttr->numOfFilterCols; ++i) {
+      SSingleColumnFilterInfo* pColFilter = &pQueryAttr->pFilterInfo[i];
+      if (pColFilter->numOfFilters > 0) {
+        tfree(pColFilter->pFilters);
+      }
+    }
+
+    pQueryAttr->pExpr1 = destroyQueryFuncExpr(pQueryAttr->pExpr1, pQueryAttr->numOfOutput);
+    pQueryAttr->pExpr2 = destroyQueryFuncExpr(pQueryAttr->pExpr2, pQueryAttr->numOfExpr2);
+
+    tfree(pQueryAttr->tagColList);
+    tfree(pQueryAttr->pFilterInfo);
+
+    if (pQueryAttr->colList != NULL) {
+      for (int32_t i = 0; i < pQueryAttr->numOfCols; i++) {
+        SColumnInfo* column = pQueryAttr->colList + i;
+        freeColumnFilterInfo(column->filterInfo, column->numOfFilters);
+      }
+      tfree(pQueryAttr->colList);
+    }
+
+    if (pQueryAttr->pGroupbyExpr != NULL) {
+      taosArrayDestroy(pQueryAttr->pGroupbyExpr->columnInfo);
+      tfree(pQueryAttr->pGroupbyExpr);
+    }
+  }
+}
+