[td-2859] refactor and fix memory leaks.

src/client/inc/tscLocalMerge.h

@@ -44,26 +44,16 @@ typedef struct SLocalMerger {
   int32_t                numOfCompleted;
   int32_t                numOfVnode;
   SLoserTreeInfo *       pLoserTree;
-  char *                 prevRowOfInput;
   tFilePage *            pResultBuf;
   int32_t                nResultBufSize;
   tFilePage *            pTempBuffer;
   struct SQLFunctionCtx *pCtx;
   int32_t                rowSize;      // size of each intermediate result.
-  bool                   hasPrevRow;   // cannot be released
-  bool                   hasUnprocessedRow;
   tOrderDescriptor *     pDesc;
   SColumnModel *         resColModel;
   SColumnModel*          finalModel;
   tExtMemBuffer **       pExtMemBuffer;      // disk-based buffer
-  SFillInfo*             pFillInfo;          // interpolation support structure
-  char*                  pFinalRes;          // result data after interpo
-  tFilePage*             discardData;
-  bool                   discard;
-  int32_t                offset;             // limit offset value
   bool                   orderPrjOnSTable;   // projection query on stable
-  char*                  tagBuf;             // max tag buffer
-  int32_t                tagBufLen;
 } SLocalMerger;
 
 typedef struct SRetrieveSupport {
@@ -96,7 +86,7 @@ void tscCreateLocalMerger(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrde
 
 void tscDestroyLocalMerger(SSqlObj *pSql);
 
-int32_t tscDoLocalMerge(SSqlObj *pSql);
+//int32_t tscDoLocalMerge(SSqlObj *pSql);
 
 #ifdef __cplusplus
 }

src/client/src/tscServer.c

@@ -1383,7 +1383,7 @@ int tscBuildCreateTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
     pMsg = (char *)pSchema;
     if (type == TSQL_CREATE_STREAM) {  // check if it is a stream sql
-      SQuerySqlNode *pQuerySql = pInfo->pCreateTableInfo->pSelect;
+      SSqlNode *pQuerySql = pInfo->pCreateTableInfo->pSelect;
 
       strncpy(pMsg, pQuerySql->sqlstr.z, pQuerySql->sqlstr.n + 1);
       pCreateMsg->sqlLen = htons(pQuerySql->sqlstr.n + 1);

src/client/src/tscSubquery.c

@@ -3590,6 +3590,8 @@ void* createQueryInfoFromQueryNode(SQueryInfo* pQueryInfo, SExprInfo* pExprs, ST
   STsBufInfo bufInfo = {0};
   SQueryParam param = {.pOperator = pa};
   /*int32_t code = */initQInfo(&bufInfo, NULL, pSourceOperator, pQInfo, &param, NULL, 0, merger);
+  taosArrayDestroy(pa);
+
   return pQInfo;
 
   _cleanup:

src/client/src/tscUtil.c

@@ -525,18 +525,14 @@ void tscSetResRawPtr(SSqlRes* pRes, SQueryInfo* pQueryInfo) {
 void tscSetResRawPtrRv(SSqlRes* pRes, SQueryInfo* pQueryInfo, SSDataBlock* pBlock) {
   assert(pRes->numOfCols > 0);
 
-//  int32_t offset = 0;
-
   for (int32_t i = 0; i < pQueryInfo->fieldsInfo.numOfOutput; ++i) {
     SInternalField* pInfo = (SInternalField*)TARRAY_GET_ELEM(pQueryInfo->fieldsInfo.internalField, i);
 
     SColumnInfoData* pColData = taosArrayGet(pBlock->pDataBlock, i);
 
-    pRes->urow[i] = pColData->pData/* + offset * pColData->info.bytes*/;
+    pRes->urow[i] = pColData->pData;
     pRes->length[i] = pInfo->field.bytes;
 
-    //offset += pInfo->field.bytes;
-
     // generated the user-defined column result
     if (pInfo->pExpr->pExpr == NULL && TSDB_COL_IS_UD_COL(pInfo->pExpr->base.colInfo.flag)) {
       if (pInfo->pExpr->base.param[1].nType == TSDB_DATA_TYPE_NULL) {
@@ -609,7 +605,7 @@ static SColumnInfo* extractColumnInfoFromResult(STableMeta* pTableMeta, SArray*
 }
 
 typedef struct SDummyInputInfo {
-  SSDataBlock     block;
+  SSDataBlock    *block;
   SSqlRes        *pRes;  // refactor: remove it
 } SDummyInputInfo;
 
@@ -619,7 +615,7 @@ SSDataBlock* doGetDataBlock(void* param, bool* newgroup) {
   SDummyInputInfo *pInput = pOperator->info;
   char* pData = pInput->pRes->data;
 
-  SSDataBlock* pBlock = &pInput->block;
+  SSDataBlock* pBlock = pInput->block;
   pBlock->info.rows = pInput->pRes->numOfRows;
   if (pBlock->info.rows == 0) {
     return NULL;
@@ -638,30 +634,47 @@ SSDataBlock* doGetDataBlock(void* param, bool* newgroup) {
   return pBlock;
 }
 
+static void destroyDummyInputOperator(void* param, int32_t numOfOutput) {
+  SDummyInputInfo* pInfo = (SDummyInputInfo*) param;
+
+  // tricky
+  for(int32_t i = 0; i < numOfOutput; ++i) {
+    SColumnInfoData* pColInfoData = taosArrayGet(pInfo->block->pDataBlock, i);
+    pColInfoData->pData = NULL;
+  }
+
+  pInfo->block = destroyOutputBuf(pInfo->block);
+  pInfo->pRes = NULL;
+}
+
+// todo this operator servers as the adapter for Operator tree and SqlRes result, remove it later
 SOperatorInfo* createDummyInputOperator(char* pResult, SSchema* pSchema, int32_t numOfCols) {
   assert(numOfCols > 0);
-
   SDummyInputInfo* pInfo = calloc(1, sizeof(SDummyInputInfo));
+
   pInfo->pRes = (SSqlRes*) pResult;
 
-  pInfo->block.info.numOfCols = numOfCols;
-  pInfo->block.pDataBlock = taosArrayInit(numOfCols, sizeof(SColumnInfoData));
+  pInfo->block = calloc(numOfCols, sizeof(SSDataBlock));
+  pInfo->block->info.numOfCols = numOfCols;
+
+  pInfo->block->pDataBlock = taosArrayInit(numOfCols, sizeof(SColumnInfoData));
   for(int32_t i = 0; i < numOfCols; ++i) {
     SColumnInfoData colData = {0};
     colData.info.bytes = pSchema[i].bytes;
     colData.info.type  = pSchema[i].type;
     colData.info.colId = pSchema[i].colId;
 
-    taosArrayPush(pInfo->block.pDataBlock, &colData);
+    taosArrayPush(pInfo->block->pDataBlock, &colData);
   }
 
   SOperatorInfo* pOptr = calloc(1, sizeof(SOperatorInfo));
   pOptr->name          = "DummyInputOperator";
   pOptr->operatorType  = OP_DummyInput;
+  pOptr->numOfOutput   = numOfCols;
   pOptr->blockingOptr  = false;
   pOptr->info          = pInfo;
   pOptr->exec          = doGetDataBlock;
-
+  pOptr->cleanup       = destroyDummyInputOperator;
   return pOptr;
 }
 
@@ -683,18 +696,12 @@ void prepareInputDataFromUpstream(SSqlRes* pRes, SQueryInfo* pQueryInfo) {
   if (pQueryInfo->pDownstream != NULL) {
     // handle the following query process
     SQueryInfo *px = pQueryInfo->pDownstream;
-    SColumnInfo* colInfo = extractColumnInfoFromResult(px->pTableMetaInfo[0]->pTableMeta, px->colList);
+    SColumnInfo* pColumnInfo = extractColumnInfoFromResult(px->pTableMetaInfo[0]->pTableMeta, px->colList);
     int32_t numOfOutput = tscSqlExprNumOfExprs(px);
 
-    SExprInfo      *exprInfo = NULL;
-    SQLFunctionCtx *pCtx = calloc(numOfOutput, sizeof(SQLFunctionCtx));
-
     int32_t numOfCols = taosArrayGetSize(px->colList);
-    SQueriedTableInfo info = {.colList = colInfo, .numOfCols = numOfCols,};
-
-    /*int32_t code = */createQueryFunc(&info, numOfOutput, &exprInfo, px->exprList->pData, NULL, px->type, NULL);
+    SQueriedTableInfo info = {.colList = pColumnInfo, .numOfCols = numOfCols,};
     SSchema* pSchema = tscGetTableSchema(px->pTableMetaInfo[0]->pTableMeta);
-    tsCreateSQLFunctionCtx(px, pCtx, pSchema);
 
     STableGroupInfo tableGroupInfo = {.numOfTables = 1, .pGroupList = taosArrayInit(1, POINTER_BYTES),};
     tableGroupInfo.map = taosHashInit(1, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_NO_LOCK);
@@ -708,11 +715,15 @@ void prepareInputDataFromUpstream(SSqlRes* pRes, SQueryInfo* pQueryInfo) {
 
     SOperatorInfo* pSourceOptr = createDummyInputOperator((char*)pRes, pSchema, numOfOutput);
 
+    SExprInfo *exprInfo = NULL;
+    /*int32_t code = */createQueryFunc(&info, numOfOutput, &exprInfo, px->exprList->pData, NULL, px->type, NULL);
     px->pQInfo = createQueryInfoFromQueryNode(px, exprInfo, &tableGroupInfo, pSourceOptr, NULL, NULL, MASTER_SCAN);
 
     uint64_t qId = 0;
     qTableQuery(px->pQInfo, &qId);
     convertQueryResult(pRes, px);
+
+    tfree(pColumnInfo);
   }
 }
 
@@ -750,9 +761,28 @@ void tscFreeQueryInfo(SSqlCmd* pCmd, bool removeMeta) {
   
   for (int32_t i = 0; i < pCmd->numOfClause; ++i) {
     SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, i);
+
+    // recursive call it
+    if (taosArrayGetSize(pQueryInfo->pUpstream) > 0) {
+      SQueryInfo* pUp = taosArrayGetP(pQueryInfo->pUpstream, 0);
+      freeQueryInfoImpl(pUp);
+      clearAllTableMetaInfo(pUp, removeMeta);
+      if (pUp->pQInfo != NULL) {
+        qDestroyQueryInfo(pUp->pQInfo);
+        pUp->pQInfo = NULL;
+      }
+
+      tfree(pUp);
+    }
     
     freeQueryInfoImpl(pQueryInfo);
     clearAllTableMetaInfo(pQueryInfo, removeMeta);
+
+    if (pQueryInfo->pQInfo != NULL) {
+      qDestroyQueryInfo(pQueryInfo->pQInfo);
+      pQueryInfo->pQInfo = NULL;
+    }
+
     tfree(pQueryInfo);
   }
   
@@ -2312,7 +2342,11 @@ void clearAllTableMetaInfo(SQueryInfo* pQueryInfo, bool removeMeta) {
   for(int32_t i = 0; i < pQueryInfo->numOfTables; ++i) {
     STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, i);
 
-    if (removeMeta) {  
+    if (pTableMetaInfo->pTableMeta && pTableMetaInfo->pTableMeta->tableType == TSDB_TEMP_TABLE) {
+      tfree(pTableMetaInfo->pTableMeta);
+    }
+
+    if (removeMeta) {
       char name[TSDB_TABLE_FNAME_LEN] = {0};
       tNameExtractFullName(&pTableMetaInfo->name, name);
     

src/inc/tsdb.h

@@ -221,7 +221,7 @@ typedef struct {
 
 typedef struct {
   uint32_t  numOfTables;
-  SArray *  pGroupList;
+  SArray   *pGroupList;
   SHashObj *map;  // speedup acquire the tableQueryInfo by table uid
 } STableGroupInfo;
 

src/query/inc/qExecutor.h

@@ -503,6 +503,8 @@ SSDataBlock* doMultiwayMergeSort(void* param, bool* newgroup);
 SSDataBlock* doSLimit(void* param, bool* newgroup);
 
 SSDataBlock* createOutputBuf(SExprInfo* pExpr, int32_t numOfOutput, int32_t numOfRows);
+void* destroyOutputBuf(SSDataBlock* pBlock);
+
 void setInputDataBlock(SOperatorInfo* pOperator, SQLFunctionCtx* pCtx, SSDataBlock* pBlock, int32_t order);
 int32_t getNumOfResult(SQueryRuntimeEnv *pRuntimeEnv, SQLFunctionCtx* pCtx, int32_t numOfOutput);
 void finalizeQueryResult(SOperatorInfo* pOperator, SQLFunctionCtx* pCtx, SResultRowInfo* pResultRowInfo, int32_t* rowCellInfoOffset);

src/query/inc/qSqlparser.h

@@ -40,8 +40,8 @@ enum SQL_NODE_TYPE {
 };
 
 enum SQL_NODE_FROM_TYPE {
-  SQL_NODE_FROM_SUBQUERY  = 1,
-  SQL_NODE_FROM_NAMELIST  = 2,
+  SQL_NODE_FROM_SUBQUERY   = 1,
+  SQL_NODE_FROM_TABLELIST  = 2,
 };
 
 extern char tTokenTypeSwitcher[13];
@@ -83,11 +83,11 @@ typedef struct SSessionWindowVal {
   SStrToken          gap;
 } SSessionWindowVal;
 
-struct SFromInfo;
+struct SRelationInfo;
 
-typedef struct SQuerySqlNode {
+typedef struct SSqlNode {
   struct SArray     *pSelNodeList; // select clause
-  struct SFromInfo  *from;         // from clause SArray<SQuerySqlNode>
+  struct SRelationInfo  *from;     // from clause SArray<SSqlNode>
   struct tSqlExpr   *pWhere;       // where clause [optional]
   SArray            *pGroupby;     // groupby clause, only for tags[optional], SArray<tVariantListItem>
   SArray            *pSortOrder;   // orderby [optional],  SArray<tVariantListItem>
@@ -98,25 +98,22 @@ typedef struct SQuerySqlNode {
   SLimitVal          limit;        // limit offset [optional]
   SLimitVal          slimit;       // group limit offset [optional]
   SStrToken          sqlstr;       // sql string in select clause
-} SQuerySqlNode;
+} SSqlNode;
 
 typedef struct STableNamePair {
   SStrToken name;
   SStrToken aliasName;
 } STableNamePair;
 
-typedef struct SSubclauseInfo {  // "UNION" multiple select sub-clause
-  SQuerySqlNode    **pClause;
-  int32_t            numOfClause;
-} SSubclauseInfo;
+//typedef struct SSubclauseInfo {  // "UNION" multiple select sub-clause
+//  SSqlNode    **pClause;
+//  int32_t       numOfClause;
+//} SSubclauseInfo;
 
-typedef struct SFromInfo {
-  int32_t            type;        // nested query|table name list
-  union {
-    SSubclauseInfo   pNode;
-    SArray          *tableList;   // SArray<STableNamePair>
-  };
-} SFromInfo;
+typedef struct SRelationInfo {
+  int32_t       type;        // nested query|table name list
+  SArray       *list;        // SArray<STableNamePair>|SArray<SSqlNode*>
+} SRelationInfo;
 
 typedef struct SCreatedTableInfo {
   SStrToken          name;        // table name token
@@ -139,7 +136,7 @@ typedef struct SCreateTableSql {
   } colInfo;
 
   SArray            *childTableInfo;        // SArray<SCreatedTableInfo>
-  SQuerySqlNode     *pSelect;
+  SSqlNode     *pSelect;
 } SCreateTableSql;
 
 typedef struct SAlterTableInfo {
@@ -216,7 +213,7 @@ typedef struct SMiscInfo {
 typedef struct SSqlInfo {
   int32_t            type;
   bool               valid;
-  SSubclauseInfo     subclauseInfo;
+  SArray            *list;    // todo refactor
   char               msg[256];
   union {
     SCreateTableSql *pCreateTableInfo;
@@ -253,9 +250,9 @@ SArray *tVariantListAppend(SArray *pList, tVariant *pVar, uint8_t sortOrder);
 SArray *tVariantListInsert(SArray *pList, tVariant *pVar, uint8_t sortOrder, int32_t index);
 SArray *tVariantListAppendToken(SArray *pList, SStrToken *pAliasToken, uint8_t sortOrder);
 
-SFromInfo *setTableNameList(SFromInfo* pFromInfo, SStrToken *pName, SStrToken* pAlias);
-SFromInfo *setSubquery(SFromInfo* pFromInfo, SSubclauseInfo* pSqlNode);
-void      *destroyFromInfo(SFromInfo* pFromInfo);
+SRelationInfo *setTableNameList(SRelationInfo* pFromInfo, SStrToken *pName, SStrToken* pAlias);
+SRelationInfo *setSubquery(SRelationInfo* pFromInfo, SArray* pSqlNode);
+void      *destroyFromInfo(SRelationInfo* pFromInfo);
 
 // sql expr leaf node
 tSqlExpr *tSqlExprCreateIdValue(SStrToken *pToken, int32_t optrType);
@@ -270,23 +267,22 @@ void      tSqlExprDestroy(tSqlExpr *pExpr);
 SArray   *tSqlExprListAppend(SArray *pList, tSqlExpr *pNode, SStrToken *pDistinct, SStrToken *pToken);
 void      tSqlExprListDestroy(SArray *pList);
 
-SQuerySqlNode *tSetQuerySqlNode(SStrToken *pSelectToken, SArray *pSelNodeList, SFromInfo *pFrom, tSqlExpr *pWhere,
+SSqlNode *tSetQuerySqlNode(SStrToken *pSelectToken, SArray *pSelNodeList, SRelationInfo *pFrom, tSqlExpr *pWhere,
                                 SArray *pGroupby, SArray *pSortOrder, SIntervalVal *pInterval, SSessionWindowVal *ps,
                                 SStrToken *pSliding, SArray *pFill, SLimitVal *pLimit, SLimitVal *pgLimit);
 
-SCreateTableSql *tSetCreateTableInfo(SArray *pCols, SArray *pTags, SQuerySqlNode *pSelect, int32_t type);
+SCreateTableSql *tSetCreateTableInfo(SArray *pCols, SArray *pTags, SSqlNode *pSelect, int32_t type);
 
 SAlterTableInfo *tSetAlterTableInfo(SStrToken *pTableName, SArray *pCols, SArray *pVals, int32_t type, int16_t tableTable);
 SCreatedTableInfo createNewChildTableInfo(SStrToken *pTableName, SArray *pTagNames, SArray *pTagVals, SStrToken *pToken, SStrToken* igExists);
 
-void destroyAllSelectClause(SSubclauseInfo *pSql);
-void destroyQuerySqlNode(SQuerySqlNode *pSql);
+void destroyAllSqlNode(SArray *pSqlNode);
+void destroySqlNode(SSqlNode *pSql);
 void freeCreateTableInfo(void* p);
 
-SSqlInfo       *setSqlInfo(SSqlInfo *pInfo, void *pSqlExprInfo, SStrToken *pTableName, int32_t type);
-SSubclauseInfo *setSubclause(SSubclauseInfo *pClause, void *pSqlExprInfo);
-
-SSubclauseInfo *appendSelectClause(SSubclauseInfo *pInfo, void *pSubclause);
+SSqlInfo *setSqlInfo(SSqlInfo *pInfo, void *pSqlExprInfo, SStrToken *pTableName, int32_t type);
+SArray   *setSubclause(SArray *pList, void *pSqlNode);
+SArray   *appendSelectClause(SArray *pList, void *pSubclause);
 
 void setCreatedTableName(SSqlInfo *pInfo, SStrToken *pTableNameToken, SStrToken *pIfNotExists);
 

src/query/inc/sql.y

@@ -450,16 +450,16 @@ tagitem(A) ::= PLUS(X) FLOAT(Y).  {
 }
 
 //////////////////////// The SELECT statement /////////////////////////////////
-%type select {SQuerySqlNode*}
-%destructor select {destroyQuerySqlNode($$);}
+%type select {SSqlNode*}
+%destructor select {destroySqlNode($$);}
 select(A) ::= SELECT(T) selcollist(W) from(X) where_opt(Y) interval_opt(K) session_option(H) fill_opt(F) sliding_opt(S) groupby_opt(P) orderby_opt(Z) having_opt(N) slimit_opt(G) limit_opt(L). {
   A = tSetQuerySqlNode(&T, W, X, Y, P, Z, &K, &H, &S, F, &L, &G);
 }
 
 select(A) ::= LP select(B) RP. {A = B;}
 
-%type union {SSubclauseInfo*}
-%destructor union {destroyAllSelectClause($$);}
+%type union {SArray*}
+%destructor union {destroyAllSqlNode($$);}
 union(Y) ::= select(X). { Y = setSubclause(NULL, X); }
 union(Y) ::= union(Z) UNION ALL select(X). { Y = appendSelectClause(Z, X); }
 
@@ -505,11 +505,11 @@ distinct(X) ::= DISTINCT(Y). { X = Y;  }
 distinct(X) ::= .            { X.n = 0;}
 
 // A complete FROM clause.
-%type from {SFromInfo*}
+%type from {SRelationInfo*}
 from(A) ::= FROM tablelist(X).                 {A = X;}
 from(A) ::= FROM LP union(Y) RP.               {A = setSubquery(NULL, Y);}
 
-%type tablelist {SFromInfo*}
+%type tablelist {SRelationInfo*}
 tablelist(A) ::= ids(X) cpxName(Y).                     {
   X.n += Y.n;
   A = setTableNameList(NULL, &X, NULL);

src/query/src/qExecutor.c

@@ -201,7 +201,7 @@ SSDataBlock* createOutputBuf(SExprInfo* pExpr, int32_t numOfOutput, int32_t numO
   return res;
 }
 
-static void* destroyOutputBuf(SSDataBlock* pBlock) {
+void* destroyOutputBuf(SSDataBlock* pBlock) {
   if (pBlock == NULL) {
     return NULL;
   }

src/query/src/qSqlParser.c

@@ -452,13 +452,13 @@ SArray *tVariantListInsert(SArray *pList, tVariant *pVar, uint8_t sortOrder, int
   return pList;
 }
 
-SFromInfo *setTableNameList(SFromInfo* pFromInfo, SStrToken *pName, SStrToken* pAlias) {
-  if (pFromInfo == NULL) {
-    pFromInfo = calloc(1, sizeof(SFromInfo));
-    pFromInfo->tableList = taosArrayInit(4, sizeof(STableNamePair));
+SRelationInfo *setTableNameList(SRelationInfo* pRelationInfo, SStrToken *pName, SStrToken* pAlias) {
+  if (pRelationInfo == NULL) {
+    pRelationInfo = calloc(1, sizeof(SRelationInfo));
+    pRelationInfo->list = taosArrayInit(4, sizeof(STableNamePair));
   }
 
-  pFromInfo->type = SQL_NODE_FROM_NAMELIST;
+  pRelationInfo->type = SQL_NODE_FROM_TABLELIST;
   STableNamePair p = {.name = *pName};
   if (pAlias != NULL) {
     p.aliasName = *pAlias;
@@ -466,34 +466,39 @@ SFromInfo *setTableNameList(SFromInfo* pFromInfo, SStrToken *pName, SStrToken* p
     TPARSER_SET_NONE_TOKEN(p.aliasName);
   }
 
-  taosArrayPush(pFromInfo->tableList, &p);
-
-  return pFromInfo;
+  taosArrayPush(pRelationInfo->list, &p);
+  return pRelationInfo;
 }
 
-SFromInfo *setSubquery(SFromInfo* pFromInfo, SSubclauseInfo* pSqlNode) {
-  if (pFromInfo == NULL) {
-    pFromInfo = calloc(1, sizeof(SFromInfo));
+SRelationInfo* setSubquery(SRelationInfo* pRelationInfo, SArray* pList) {
+  if (pRelationInfo == NULL) {
+    pRelationInfo = calloc(1, sizeof(SRelationInfo));
+    pRelationInfo->list = taosArrayInit(4, POINTER_BYTES);
   }
 
-  pFromInfo->type = SQL_NODE_FROM_SUBQUERY;
-  pFromInfo->pNode = *pSqlNode;
+  pRelationInfo->type = SQL_NODE_FROM_SUBQUERY;
+  taosArrayPush(pRelationInfo->list, &pList);
 
-  return pFromInfo;
+  return pRelationInfo;
 }
 
-void* destroyFromInfo(SFromInfo* pFromInfo) {
-  if (pFromInfo == NULL) {
+void* destroyFromInfo(SRelationInfo* pRelationInfo) {
+  if (pRelationInfo == NULL) {
     return NULL;
   }
 
-  if (pFromInfo->type == SQL_NODE_FROM_NAMELIST) {
-    taosArrayDestroy(pFromInfo->tableList);
+  if (pRelationInfo->type == SQL_NODE_FROM_TABLELIST) {
+    taosArrayDestroy(pRelationInfo->list);
   } else {
-    destroyAllSelectClause(&pFromInfo->pNode);
+    size_t size = taosArrayGetSize(pRelationInfo->list);
+    for(int32_t i = 0; i < size; ++i) {
+      SArray* pa = taosArrayGetP(pRelationInfo->list, 0);
+      destroyAllSqlNode(pa);
+    }
+    taosArrayDestroy(pRelationInfo->list);
   }
 
-  tfree(pFromInfo);
+  tfree(pRelationInfo);
   return NULL;
 }
 
@@ -637,13 +642,13 @@ void tSetColumnType(TAOS_FIELD *pField, SStrToken *type) {
 /*
  * extract the select info out of sql string
  */
-SQuerySqlNode *tSetQuerySqlNode(SStrToken *pSelectToken, SArray *pSelNodeList, SFromInfo *pFrom, tSqlExpr *pWhere,
+SSqlNode *tSetQuerySqlNode(SStrToken *pSelectToken, SArray *pSelNodeList, SRelationInfo *pFrom, tSqlExpr *pWhere,
                                 SArray *pGroupby, SArray *pSortOrder, SIntervalVal *pInterval,
                                 SSessionWindowVal *pSession, SStrToken *pSliding, SArray *pFill, SLimitVal *pLimit,
                                 SLimitVal *psLimit) {
   assert(pSelNodeList != NULL);
 
-  SQuerySqlNode *pSqlNode = calloc(1, sizeof(SQuerySqlNode));
+  SSqlNode *pSqlNode = calloc(1, sizeof(SSqlNode));
 
   // all later sql string are belonged to the stream sql
   pSqlNode->sqlstr   = *pSelectToken;
@@ -706,46 +711,47 @@ void freeCreateTableInfo(void* p) {
   tfree(pInfo->tagdata.data);
 }
 
-void destroyQuerySqlNode(SQuerySqlNode *pQuerySql) {
-  if (pQuerySql == NULL) {
+void destroySqlNode(SSqlNode *pSqlNode) {
+  if (pSqlNode == NULL) {
     return;
   }
 
-  tSqlExprListDestroy(pQuerySql->pSelNodeList);
+  tSqlExprListDestroy(pSqlNode->pSelNodeList);
   
-  pQuerySql->pSelNodeList = NULL;
+  pSqlNode->pSelNodeList = NULL;
 
-  tSqlExprDestroy(pQuerySql->pWhere);
-  pQuerySql->pWhere = NULL;
+  tSqlExprDestroy(pSqlNode->pWhere);
+  pSqlNode->pWhere = NULL;
   
-  taosArrayDestroyEx(pQuerySql->pSortOrder, freeVariant);
-  pQuerySql->pSortOrder = NULL;
+  taosArrayDestroyEx(pSqlNode->pSortOrder, freeVariant);
+  pSqlNode->pSortOrder = NULL;
 
-  taosArrayDestroyEx(pQuerySql->pGroupby, freeVariant);
-  pQuerySql->pGroupby = NULL;
+  taosArrayDestroyEx(pSqlNode->pGroupby, freeVariant);
+  pSqlNode->pGroupby = NULL;
 
-  pQuerySql->from = destroyFromInfo(pQuerySql->from);
+  pSqlNode->from = destroyFromInfo(pSqlNode->from);
 
-  taosArrayDestroyEx(pQuerySql->fillType, freeVariant);
-  pQuerySql->fillType = NULL;
+  taosArrayDestroyEx(pSqlNode->fillType, freeVariant);
+  pSqlNode->fillType = NULL;
 
-  free(pQuerySql);
+  free(pSqlNode);
 }
 
-void destroyAllSelectClause(SSubclauseInfo *pClause) {
-  if (pClause == NULL || pClause->numOfClause == 0) {
+void destroyAllSqlNode(SArray *pList) {
+  if (pList == NULL) {
     return;
   }
 
-  for(int32_t i = 0; i < pClause->numOfClause; ++i) {
-    SQuerySqlNode *pQuerySql = pClause->pClause[i];
-    destroyQuerySqlNode(pQuerySql);
+  size_t size = taosArrayGetSize(pList);
+  for(int32_t i = 0; i < size; ++i) {
+    SSqlNode *pNode = taosArrayGetP(pList, 0);
+    destroySqlNode(pNode);
   }
-  
-  tfree(pClause->pClause);
+
+  taosArrayDestroy(pList);
 }
 
-SCreateTableSql *tSetCreateTableInfo(SArray *pCols, SArray *pTags, SQuerySqlNode *pSelect, int32_t type) {
+SCreateTableSql *tSetCreateTableInfo(SArray *pCols, SArray *pTags, SSqlNode *pSelect, int32_t type) {
   SCreateTableSql *pCreate = calloc(1, sizeof(SCreateTableSql));
 
   switch (type) {
@@ -813,7 +819,7 @@ SAlterTableInfo *tSetAlterTableInfo(SStrToken *pTableName, SArray *pCols, SArray
 }
 
 void* destroyCreateTableSql(SCreateTableSql* pCreate) {
-  destroyQuerySqlNode(pCreate->pSelect);
+  destroySqlNode(pCreate->pSelect);
 
   taosArrayDestroy(pCreate->colInfo.pColumns);
   taosArrayDestroy(pCreate->colInfo.pTagColumns);
@@ -828,7 +834,7 @@ void SqlInfoDestroy(SSqlInfo *pInfo) {
   if (pInfo == NULL) return;
 
   if (pInfo->type == TSDB_SQL_SELECT) {
-    destroyAllSelectClause(&pInfo->subclauseInfo);
+    destroyAllSqlNode(pInfo->list);
   } else if (pInfo->type == TSDB_SQL_CREATE_TABLE) {
     pInfo->pCreateTableInfo = destroyCreateTableSql(pInfo->pCreateTableInfo);
   } else if (pInfo->type == TSDB_SQL_ALTER_TABLE) {
@@ -849,31 +855,20 @@ void SqlInfoDestroy(SSqlInfo *pInfo) {
   }
 }
 
-SSubclauseInfo* setSubclause(SSubclauseInfo* pSubclause, void *pSqlExprInfo) {
-  if (pSubclause == NULL) {
-    pSubclause = calloc(1, sizeof(SSubclauseInfo));
-  }
-  
-  int32_t newSize = pSubclause->numOfClause + 1;
-  char* tmp = realloc(pSubclause->pClause, newSize * POINTER_BYTES);
-  if (tmp == NULL) {
-    return pSubclause;
+SArray* setSubclause(SArray* pList, void *pSqlNode) {
+  if (pList == NULL) {
+    pList = taosArrayInit(1, POINTER_BYTES);
   }
   
-  pSubclause->pClause = (SQuerySqlNode**) tmp;
-  
-  pSubclause->pClause[newSize - 1] = pSqlExprInfo;
-  pSubclause->numOfClause++;
-  
-  return pSubclause;
+  taosArrayPush(pList, &pSqlNode);
+  return pList;
 }
 
 SSqlInfo* setSqlInfo(SSqlInfo *pInfo, void *pSqlExprInfo, SStrToken *pTableName, int32_t type) {
   pInfo->type = type;
   
   if (type == TSDB_SQL_SELECT) {
-    pInfo->subclauseInfo = *(SSubclauseInfo*) pSqlExprInfo;
-    free(pSqlExprInfo);
+    pInfo->list = (SArray*) pSqlExprInfo;
   } else {
     pInfo->pCreateTableInfo = pSqlExprInfo;
   }
@@ -885,16 +880,9 @@ SSqlInfo* setSqlInfo(SSqlInfo *pInfo, void *pSqlExprInfo, SStrToken *pTableName,
   return pInfo;
 }
 
-SSubclauseInfo* appendSelectClause(SSubclauseInfo *pQueryInfo, void *pSubclause) {
-  char* tmp = realloc(pQueryInfo->pClause, (pQueryInfo->numOfClause + 1) * POINTER_BYTES);
-  if (tmp == NULL) {  // out of memory
-    return pQueryInfo;
-  }
-  
-  pQueryInfo->pClause = (SQuerySqlNode**) tmp;
-  pQueryInfo->pClause[pQueryInfo->numOfClause++] = pSubclause;
-  
-  return pQueryInfo;
+SArray* appendSelectClause(SArray *pList, void *pSubclause) {
+  taosArrayPush(pList, &pSubclause);
+  return pList;
 }
 
 void setCreatedTableName(SSqlInfo *pInfo, SStrToken *pTableNameToken, SStrToken *pIfNotExists) {

src/query/src/sql.c

@@ -105,20 +105,19 @@ typedef union {
   ParseTOKENTYPE yy0;
   SCreateTableSql* yy14;
   int yy20;
+  SSqlNode* yy116;
   tSqlExpr* yy118;
   SArray* yy159;
   SIntervalVal yy184;
   SCreatedTableInfo yy206;
+  SRelationInfo* yy236;
   SSessionWindowVal yy249;
-  SQuerySqlNode* yy272;
   int64_t yy317;
   SCreateDbInfo yy322;
   SCreateAcctInfo yy351;
-  SSubclauseInfo* yy391;
   TAOS_FIELD yy407;
   SLimitVal yy440;
   tVariant yy488;
-  SFromInfo* yy514;
 } YYMINORTYPE;
 #ifndef YYSTACKDEPTH
 #define YYSTACKDEPTH 100
@@ -1426,7 +1425,7 @@ destroyCreateTableSql((yypminor->yy14));
       break;
     case 234: /* select */
 {
-destroyQuerySqlNode((yypminor->yy272));
+destroySqlNode((yypminor->yy116));
 }
       break;
     case 237: /* selcollist */
@@ -1446,7 +1445,7 @@ tSqlExprDestroy((yypminor->yy118));
       break;
     case 249: /* union */
 {
-destroyAllSelectClause((yypminor->yy391));
+destroyAllSqlNode((yypminor->yy159));
 }
       break;
     case 257: /* sortitem */
@@ -2540,7 +2539,7 @@ static void yy_reduce(
         break;
       case 141: /* create_table_args ::= ifnotexists ids cpxName AS select */
 {
-  yylhsminor.yy14 = tSetCreateTableInfo(NULL, NULL, yymsp[0].minor.yy272, TSQL_CREATE_STREAM);
+  yylhsminor.yy14 = tSetCreateTableInfo(NULL, NULL, yymsp[0].minor.yy116, TSQL_CREATE_STREAM);
   setSqlInfo(pInfo, yylhsminor.yy14, NULL, TSDB_SQL_CREATE_TABLE);
 
   yymsp[-3].minor.yy0.n += yymsp[-2].minor.yy0.n;
@@ -2595,29 +2594,29 @@ static void yy_reduce(
         break;
       case 156: /* select ::= SELECT selcollist from where_opt interval_opt session_option fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
 {
-  yylhsminor.yy272 = tSetQuerySqlNode(&yymsp[-12].minor.yy0, yymsp[-11].minor.yy159, yymsp[-10].minor.yy514, yymsp[-9].minor.yy118, yymsp[-4].minor.yy159, yymsp[-3].minor.yy159, &yymsp[-8].minor.yy184, &yymsp[-7].minor.yy249, &yymsp[-5].minor.yy0, yymsp[-6].minor.yy159, &yymsp[0].minor.yy440, &yymsp[-1].minor.yy440);
+  yylhsminor.yy116 = tSetQuerySqlNode(&yymsp[-12].minor.yy0, yymsp[-11].minor.yy159, yymsp[-10].minor.yy236, yymsp[-9].minor.yy118, yymsp[-4].minor.yy159, yymsp[-3].minor.yy159, &yymsp[-8].minor.yy184, &yymsp[-7].minor.yy249, &yymsp[-5].minor.yy0, yymsp[-6].minor.yy159, &yymsp[0].minor.yy440, &yymsp[-1].minor.yy440);
 }
-  yymsp[-12].minor.yy272 = yylhsminor.yy272;
+  yymsp[-12].minor.yy116 = yylhsminor.yy116;
         break;
       case 157: /* select ::= LP select RP */
-{yymsp[-2].minor.yy272 = yymsp[-1].minor.yy272;}
+{yymsp[-2].minor.yy116 = yymsp[-1].minor.yy116;}
         break;
       case 158: /* union ::= select */
-{ yylhsminor.yy391 = setSubclause(NULL, yymsp[0].minor.yy272); }
-  yymsp[0].minor.yy391 = yylhsminor.yy391;
+{ yylhsminor.yy159 = setSubclause(NULL, yymsp[0].minor.yy116); }
+  yymsp[0].minor.yy159 = yylhsminor.yy159;
         break;
       case 159: /* union ::= union UNION ALL select */
-{ yylhsminor.yy391 = appendSelectClause(yymsp[-3].minor.yy391, yymsp[0].minor.yy272); }
-  yymsp[-3].minor.yy391 = yylhsminor.yy391;
+{ yylhsminor.yy159 = appendSelectClause(yymsp[-3].minor.yy159, yymsp[0].minor.yy116); }
+  yymsp[-3].minor.yy159 = yylhsminor.yy159;
         break;
       case 160: /* cmd ::= union */
-{ setSqlInfo(pInfo, yymsp[0].minor.yy391, NULL, TSDB_SQL_SELECT); }
+{ setSqlInfo(pInfo, yymsp[0].minor.yy159, NULL, TSDB_SQL_SELECT); }
         break;
       case 161: /* select ::= SELECT selcollist */
 {
-  yylhsminor.yy272 = tSetQuerySqlNode(&yymsp[-1].minor.yy0, yymsp[0].minor.yy159, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+  yylhsminor.yy116 = tSetQuerySqlNode(&yymsp[-1].minor.yy0, yymsp[0].minor.yy159, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
-  yymsp[-1].minor.yy272 = yylhsminor.yy272;
+  yymsp[-1].minor.yy116 = yylhsminor.yy116;
         break;
       case 162: /* sclp ::= selcollist COMMA */
 {yylhsminor.yy159 = yymsp[-1].minor.yy159;}
@@ -2655,38 +2654,38 @@ static void yy_reduce(
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
       case 171: /* from ::= FROM tablelist */
-{yymsp[-1].minor.yy514 = yymsp[0].minor.yy514;}
+{yymsp[-1].minor.yy236 = yymsp[0].minor.yy236;}
         break;
       case 172: /* from ::= FROM LP union RP */
-{yymsp[-3].minor.yy514 = setSubquery(NULL, yymsp[-1].minor.yy391);}
+{yymsp[-3].minor.yy236 = setSubquery(NULL, yymsp[-1].minor.yy159);}
         break;
       case 173: /* tablelist ::= ids cpxName */
 {
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
-  yylhsminor.yy514 = setTableNameList(NULL, &yymsp[-1].minor.yy0, NULL);
+  yylhsminor.yy236 = setTableNameList(NULL, &yymsp[-1].minor.yy0, NULL);
 }
-  yymsp[-1].minor.yy514 = yylhsminor.yy514;
+  yymsp[-1].minor.yy236 = yylhsminor.yy236;
         break;
       case 174: /* tablelist ::= ids cpxName ids */
 {
   yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
-  yylhsminor.yy514 = setTableNameList(NULL, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
+  yylhsminor.yy236 = setTableNameList(NULL, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
 }
-  yymsp[-2].minor.yy514 = yylhsminor.yy514;
+  yymsp[-2].minor.yy236 = yylhsminor.yy236;
         break;
       case 175: /* tablelist ::= tablelist COMMA ids cpxName */
 {
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
-  yylhsminor.yy514 = setTableNameList(yymsp[-3].minor.yy514, &yymsp[-1].minor.yy0, NULL);
+  yylhsminor.yy236 = setTableNameList(yymsp[-3].minor.yy236, &yymsp[-1].minor.yy0, NULL);
 }
-  yymsp[-3].minor.yy514 = yylhsminor.yy514;
+  yymsp[-3].minor.yy236 = yylhsminor.yy236;
         break;
       case 176: /* tablelist ::= tablelist COMMA ids cpxName ids */
 {
   yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
-  yylhsminor.yy514 = setTableNameList(yymsp[-4].minor.yy514, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
+  yylhsminor.yy236 = setTableNameList(yymsp[-4].minor.yy236, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
 }
-  yymsp[-4].minor.yy514 = yylhsminor.yy514;
+  yymsp[-4].minor.yy236 = yylhsminor.yy236;
         break;
       case 177: /* tmvar ::= VARIABLE */
 {yylhsminor.yy0 = yymsp[0].minor.yy0;}

src/tsdb/src/tsdbRead.c

@@ -3414,14 +3414,16 @@ void tsdbDestroyTableGroup(STableGroupInfo *pGroupList) {
     size_t numOfTables = taosArrayGetSize(p);
     for(int32_t j = 0; j < numOfTables; ++j) {
       STable* pTable = taosArrayGetP(p, j);
-      assert(pTable != NULL);
-
-      tsdbUnRefTable(pTable);
+      if (pTable != NULL) { // in case of handling retrieve data from tsdb
+        tsdbUnRefTable(pTable);
+      }
+      //assert(pTable != NULL);
     }
 
     taosArrayDestroy(p);
   }
 
+  taosHashCleanup(pGroupList->map);
   taosArrayDestroy(pGroupList->pGroupList);
   pGroupList->numOfTables = 0;
 }