diff --git a/src/client/src/tscAsync.c b/src/client/src/tscAsync.c
index e70cd11fbe03b498d2caad93b086cfc33adf5669..99c03c65801a64eb6b913373603cfa9c48d36911 100644
--- a/src/client/src/tscAsync.c
+++ b/src/client/src/tscAsync.c
@@ -428,6 +428,7 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
       } else {
         assert(code == TSDB_CODE_SUCCESS);      
       }
+
       // param already freed by other routine and pSql in tscCache when ctrl + c 
       if (atomic_load_ptr(&pSql->param) == NULL) {
         return;
@@ -441,6 +442,20 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
       assert(pParObj->signature == pParObj && trs->subqueryIndex == pTableMetaInfo->vgroupIndex &&
           pTableMetaInfo->vgroupIndex >= 0 && pTableMetaInfo->vgroupList != NULL);
 
+      // tscProcessSql can add error into async res
+      tscProcessSql(pSql);
+      return;
+    } else if (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_TAG_FILTER_QUERY)) {
+      tscDebug("%p update table meta in local cache, continue to process sql and send corresponding tid_tag query", pSql);
+      STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+      code = tscGetTableMeta(pSql, pTableMetaInfo);
+      if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
+        return;
+      } else {
+        assert(code == TSDB_CODE_SUCCESS);
+      }
+
+      assert((tscGetNumOfTags(pTableMetaInfo->pTableMeta) != 0));
       // tscProcessSql can add error into async res
       tscProcessSql(pSql);
       return;
@@ -465,7 +480,6 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
           tscResetSqlCmdObj(pCmd, false);
 
           code = tsParseSql(pSql, true);
-
           if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
             return;
           } else if (code != TSDB_CODE_SUCCESS) {
diff --git a/src/client/src/tscLocalMerge.c b/src/client/src/tscLocalMerge.c
index c67edf5b5a8a026fc10d251218abcf96ab018359..f49c4da0cbc01ab657a82bf90baeb5adddd7241f 100644
--- a/src/client/src/tscLocalMerge.c
+++ b/src/client/src/tscLocalMerge.c
@@ -97,6 +97,9 @@ static void tscInitSqlContext(SSqlCmd *pCmd, SLocalReducer *pReducer, tOrderDesc
       pCtx->param[2].i64Key = pQueryInfo->order.order;
       pCtx->param[2].nType  = TSDB_DATA_TYPE_BIGINT;
       pCtx->param[1].i64Key = pQueryInfo->order.orderColId;
+    } else if (functionId == TSDB_FUNC_APERCT) {
+      pCtx->param[0].i64Key = pExpr->param[0].i64Key;
+      pCtx->param[0].nType  = pExpr->param[0].nType;
     }
 
     pCtx->interBufBytes = pExpr->interBytes;
diff --git a/src/client/src/tscParseInsert.c b/src/client/src/tscParseInsert.c
index 5e65126ef60c7db45ba33ca70fb4687c425c7571..f960beb5d9f3281c3a511d901e0a8b38b0547837 100644
--- a/src/client/src/tscParseInsert.c
+++ b/src/client/src/tscParseInsert.c
@@ -1309,7 +1309,7 @@ int tsParseSql(SSqlObj *pSql, bool initial) {
   if ((!pCmd->parseFinished) && (!initial)) {
     tscDebug("%p resume to parse sql: %s", pSql, pCmd->curSql);
   }
-  
+
   ret = tscAllocPayload(&pSql->cmd, TSDB_DEFAULT_PAYLOAD_SIZE);
   if (TSDB_CODE_SUCCESS != ret) {
     return ret;
diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c
index fd56001174208ffaa34eb2477e6bdf36e2a93916..b3d151ba2798b89f0ffffad33ed3b4f6a44483f8 100644
--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@@ -523,7 +523,7 @@ static void quitAllSubquery(SSqlObj* pSqlObj, SJoinSupporter* pSupporter) {
   assert(pSqlObj->subState.numOfRemain > 0);
 
   if (atomic_sub_fetch_32(&pSqlObj->subState.numOfRemain, 1) <= 0) {
-    tscError("%p all subquery return and query failed, global code:%d", pSqlObj, pSqlObj->res.code);
+    tscError("%p all subquery return and query failed, global code:%s", pSqlObj, tstrerror(pSqlObj->res.code));
     freeJoinSubqueryObj(pSqlObj);
   }
 }
@@ -565,7 +565,7 @@ int32_t tagValCompar(const void* p1, const void* p2) {
     return (tag1->len > tag2->len)? 1: -1;
   }
 
-  return strncmp(tag1->data, tag2->data, tag1->len);
+  return memcmp(tag1->data, tag2->data, tag1->len);
 }
 
 void tscBuildVgroupTableInfo(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo, SArray* tables) {
diff --git a/src/query/inc/tsqlfunction.h b/src/query/inc/tsqlfunction.h
index 3bd4aad2766954709231f55ecdccfe03209a91bc..84ca78d82249b88d68176b0a350a83fb56b8fda9 100644
--- a/src/query/inc/tsqlfunction.h
+++ b/src/query/inc/tsqlfunction.h
@@ -149,7 +149,7 @@ typedef struct SResultRowCellInfo {
   int8_t   hasResult;       // result generated, not NULL value
   bool     initialized;     // output buffer has been initialized
   bool     complete;        // query has completed
-  uint16_t numOfRes;        // num of output result in current buffer
+  uint32_t numOfRes;        // num of output result in current buffer
 } SResultRowCellInfo;
 
 #define GET_ROWCELL_INTERBUF(_c) ((void*) ((char*)(_c) + sizeof(SResultRowCellInfo)))
diff --git a/src/query/src/qAst.c b/src/query/src/qAst.c
index 847a8b8eb601250866ed2e4f29b63941c3faa19d..bc2866fb6f3a1e6325f94d1f9c4d8ddd18abbbd1 100644
--- a/src/query/src/qAst.c
+++ b/src/query/src/qAst.c
@@ -32,7 +32,6 @@
 #include "tstoken.h"
 #include "ttokendef.h"
 #include "tulog.h"
-#include "tutil.h"
 
 /*
  *
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index b365dc4283ccab8d6440a5c479102353870aa616..b992a037ed6f37bb674a0d7755653abe491ed845 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -1609,7 +1609,7 @@ static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, int16_t order
 
   pRuntimeEnv->pCtx = (SQLFunctionCtx *)calloc(pQuery->numOfOutput, sizeof(SQLFunctionCtx));
   pRuntimeEnv->rowCellInfoOffset = calloc(pQuery->numOfOutput, sizeof(int32_t));
-  pRuntimeEnv->pResultRow = getNewResultRow(pRuntimeEnv->pool);//calloc(1, sizeof(SResultRow));
+  pRuntimeEnv->pResultRow = getNewResultRow(pRuntimeEnv->pool);
 
   if (pRuntimeEnv->pResultRow == NULL || pRuntimeEnv->pCtx == NULL || pRuntimeEnv->rowCellInfoOffset == NULL) {
     goto _clean;
@@ -1745,6 +1745,7 @@ static void teardownQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv) {
 
   pRuntimeEnv->pTSBuf = tsBufDestroy(pRuntimeEnv->pTSBuf);
   taosTFree(pRuntimeEnv->keyBuf);
+  taosTFree(pRuntimeEnv->rowCellInfoOffset);
 
   taosHashCleanup(pRuntimeEnv->pResultRowHashTable);
   pRuntimeEnv->pResultRowHashTable = NULL;
diff --git a/src/query/src/qFill.c b/src/query/src/qFill.c
index a219bd6abd928866b93d00ab2ed162c1ae9bc3f3..788779b2bb28feb4547c0bb6dca970f705b185c4 100644
--- a/src/query/src/qFill.c
+++ b/src/query/src/qFill.c
@@ -170,7 +170,7 @@ int64_t getFilledNumOfRes(SFillInfo* pFillInfo, TSKEY ekey, int32_t maxNumOfRows
   int32_t numOfRows = taosNumOfRemainRows(pFillInfo);
 
   TSKEY ekey1 = ekey;
-  if (pFillInfo->order != TSDB_ORDER_ASC) {
+  if (!FILL_IS_ASC_FILL(pFillInfo)) {
     pFillInfo->endKey = taosTimeTruncate(ekey, &pFillInfo->interval, pFillInfo->precision);
   }
 
diff --git a/src/query/src/qHistogram.c b/src/query/src/qHistogram.c
index 703ee2c52129a067d1070cfbe567087ec48a7a6e..35e5906d1f797c2f53f3906bf93c6797ac766c3e 100644
--- a/src/query/src/qHistogram.c
+++ b/src/query/src/qHistogram.c
@@ -168,7 +168,7 @@ int32_t tHistogramAdd(SHistogramInfo** pHisto, double val) {
       (*pHisto)->numOfEntries += 1;
     }
   } else { /* insert a new slot */
-    if ((*pHisto)->numOfElems > 1 && idx < (*pHisto)->numOfEntries) {
+    if ((*pHisto)->numOfElems >= 1 && idx < (*pHisto)->numOfEntries) {
       if (idx > 0) {
         assert((*pHisto)->elems[idx - 1].val <= val);
       }
@@ -661,4 +661,4 @@ SHistogramInfo* tHistogramMerge(SHistogramInfo* pHisto1, SHistogramInfo* pHisto2
 
   free(pHistoBins);
   return pResHistogram;
-}
\ No newline at end of file
+}
diff --git a/src/vnode/src/vnodeRead.c b/src/vnode/src/vnodeRead.c
index faa35b0e02d783c1d0b415a60a77c6e98618041e..dd38a2d9c5952674ec5ba02640541502660c523e 100644
--- a/src/vnode/src/vnodeRead.c
+++ b/src/vnode/src/vnodeRead.c
@@ -298,7 +298,7 @@ static int32_t vnodeProcessFetchMsg(SVnodeObj *pVnode, SVReadMsg *pReadMsg) {
   }
 
   if (code != TSDB_CODE_SUCCESS) {
-    vDebug("vgId:%d, invalid handle in retrieving result, code:0x%08x, QInfo:%p", pVnode->vgId, code, (void *)pRetrieve->qhandle);
+    vError("vgId:%d, invalid handle in retrieving result, code:0x%08x, QInfo:%p", pVnode->vgId, code, (void *)pRetrieve->qhandle);
     vnodeBuildNoResultQueryRsp(pRet);
     return code;
   }
diff --git a/tests/examples/c/apitest.c b/tests/examples/c/apitest.c
index 759e16d1de285c9490d7f1af7a94de81dbadb6e4..be60a88ad70721bd6281d9ca8f1d73263a788532 100644
--- a/tests/examples/c/apitest.c
+++ b/tests/examples/c/apitest.c
@@ -9,26 +9,40 @@
 
 
 static void prepare_data(TAOS* taos) {
-  taos_query(taos, "drop database if exists test;");
+  TAOS_RES *result;
+  result = taos_query(taos, "drop database if exists test;");
+  taos_free_result(result);
   usleep(100000);
-  taos_query(taos, "create database test;");
+  result = taos_query(taos, "create database test;");
+  taos_free_result(result);
   usleep(100000);
   taos_select_db(taos, "test");
 
-  taos_query(taos, "create table meters(ts timestamp, a int) tags(area int);");
+  result = taos_query(taos, "create table meters(ts timestamp, a int) tags(area int);");
+  taos_free_result(result);
 
-  taos_query(taos, "create table t0 using meters tags(0);");
-  taos_query(taos, "create table t1 using meters tags(1);");
-  taos_query(taos, "create table t2 using meters tags(2);");
-  taos_query(taos, "create table t3 using meters tags(3);");
-  taos_query(taos, "create table t4 using meters tags(4);");
-  taos_query(taos, "create table t5 using meters tags(5);");
-  taos_query(taos, "create table t6 using meters tags(6);");
-  taos_query(taos, "create table t7 using meters tags(7);");
-  taos_query(taos, "create table t8 using meters tags(8);");
-  taos_query(taos, "create table t9 using meters tags(9);");
+  result = taos_query(taos, "create table t0 using meters tags(0);");
+  taos_free_result(result);
+  result = taos_query(taos, "create table t1 using meters tags(1);");
+  taos_free_result(result);
+  result = taos_query(taos, "create table t2 using meters tags(2);");
+  taos_free_result(result);
+  result = taos_query(taos, "create table t3 using meters tags(3);");
+  taos_free_result(result);
+  result = taos_query(taos, "create table t4 using meters tags(4);");
+  taos_free_result(result);
+  result = taos_query(taos, "create table t5 using meters tags(5);");
+  taos_free_result(result);
+  result = taos_query(taos, "create table t6 using meters tags(6);");
+  taos_free_result(result);
+  result = taos_query(taos, "create table t7 using meters tags(7);");
+  taos_free_result(result);
+  result = taos_query(taos, "create table t8 using meters tags(8);");
+  taos_free_result(result);
+  result = taos_query(taos, "create table t9 using meters tags(9);");
+  taos_free_result(result);
 
-  TAOS_RES* res = taos_query(taos, "insert into t0 values('2020-01-01 00:00:00.000', 0)"
+  result = taos_query(taos, "insert into t0 values('2020-01-01 00:00:00.000', 0)"
     " ('2020-01-01 00:01:00.000', 0)"
     " ('2020-01-01 00:02:00.000', 0)"
     " t1 values('2020-01-01 00:00:00.000', 0)"
@@ -46,10 +60,11 @@ static void prepare_data(TAOS* taos) {
     " t7 values('2020-01-01 00:01:02.000', 0)"
     " t8 values('2020-01-01 00:01:02.000', 0)"
     " t9 values('2020-01-01 00:01:02.000', 0)");
-  int affected = taos_affected_rows(res);
+  int affected = taos_affected_rows(result);
   if (affected != 18) {
     printf("\033[31m%d rows affected by last insert statement, but it should be 18\033[0m\n", affected);
   }
+  taos_free_result(result);
   // super tables subscription
   usleep(1000000);
 }
@@ -135,6 +150,7 @@ static void verify_query(TAOS* taos) {
 
   res = taos_query(taos, "select * from meters");
   taos_stop_query(res);
+  taos_free_result(res);
 }
 
 
@@ -153,23 +169,30 @@ static void verify_subscribe(TAOS* taos) {
   res = taos_consume(tsub);
   check_row_count(__LINE__, res, 0);
 
-  taos_query(taos, "insert into t0 values('2020-01-01 00:02:00.001', 0);");
-  taos_query(taos, "insert into t8 values('2020-01-01 00:01:03.000', 0);");
+  TAOS_RES *result;
+  result = taos_query(taos, "insert into t0 values('2020-01-01 00:02:00.001', 0);");
+  taos_free_result(result);
+  result = taos_query(taos, "insert into t8 values('2020-01-01 00:01:03.000', 0);");
+  taos_free_result(result);
   res = taos_consume(tsub);
   check_row_count(__LINE__, res, 2);
 
-  taos_query(taos, "insert into t2 values('2020-01-01 00:01:02.001', 0);");
-  taos_query(taos, "insert into t1 values('2020-01-01 00:03:00.001', 0);");
+  result = taos_query(taos, "insert into t2 values('2020-01-01 00:01:02.001', 0);");
+  taos_free_result(result);
+  result = taos_query(taos, "insert into t1 values('2020-01-01 00:03:00.001', 0);");
+  taos_free_result(result);
   res = taos_consume(tsub);
   check_row_count(__LINE__, res, 2);
 
-  taos_query(taos, "insert into t1 values('2020-01-01 00:03:00.002', 0);");
+  result = taos_query(taos, "insert into t1 values('2020-01-01 00:03:00.002', 0);");
+  taos_free_result(result);
   res = taos_consume(tsub);
   check_row_count(__LINE__, res, 1);
 
   // keep progress information and restart subscription
   taos_unsubscribe(tsub, 1);
-  taos_query(taos, "insert into t0 values('2020-01-01 00:04:00.000', 0);");
+  result = taos_query(taos, "insert into t0 values('2020-01-01 00:04:00.000', 0);");
+  taos_free_result(result);
   tsub = taos_subscribe(taos, 1, "test", "select * from meters;", NULL, NULL, 0);
   res = taos_consume(tsub);
   check_row_count(__LINE__, res, 24);
@@ -196,7 +219,8 @@ static void verify_subscribe(TAOS* taos) {
   res = taos_consume(tsub);
   check_row_count(__LINE__, res, 0);
 
-  taos_query(taos, "insert into t0 values('2020-01-01 00:04:00.001', 0);");
+  result = taos_query(taos, "insert into t0 values('2020-01-01 00:04:00.001', 0);");
+  taos_free_result(result);
   res = taos_consume(tsub);
   check_row_count(__LINE__, res, 1);
 
@@ -205,7 +229,8 @@ static void verify_subscribe(TAOS* taos) {
   int blockFetch = 0;
   tsub = taos_subscribe(taos, 1, "test", "select * from meters;", subscribe_callback, &blockFetch, 1000);
   usleep(2000000);
-  taos_query(taos, "insert into t0 values('2020-01-01 00:05:00.001', 0);");
+  result = taos_query(taos, "insert into t0 values('2020-01-01 00:05:00.001', 0);");
+  taos_free_result(result);
   usleep(2000000);
   taos_unsubscribe(tsub, 0);
 }
@@ -213,8 +238,9 @@ static void verify_subscribe(TAOS* taos) {
 
 void verify_prepare(TAOS* taos) {
   TAOS_RES* result = taos_query(taos, "drop database if exists test;");
+  taos_free_result(result);
   usleep(100000);
-  taos_query(taos, "create database test;");
+  result = taos_query(taos, "create database test;");
 
   int code = taos_errno(result);
   if (code != 0) {
@@ -429,7 +455,8 @@ void verify_stream(TAOS* taos) {
     NULL);
   printf("waiting for stream data\n"); 
   usleep(100000);
-  taos_query(taos, "insert into t0 values(now, 0)(now+5s,1)(now+10s, 2);");
+  TAOS_RES* result = taos_query(taos, "insert into t0 values(now, 0)(now+5s,1)(now+10s, 2);");
+  taos_free_result(result);
   usleep(200000000);
   taos_close_stream(strm);
 }
diff --git a/tests/examples/c/asyncdemo.c b/tests/examples/c/asyncdemo.c
index 1e523bd7fec9ba9fd90d1a71949f40c7be71384d..225c4f7541ec7cd7fb4784b8de94d8b47c4e3e36 100644
--- a/tests/examples/c/asyncdemo.c
+++ b/tests/examples/c/asyncdemo.c
@@ -46,6 +46,34 @@ void taos_insert_call_back(void *param, TAOS_RES *tres, int code);
 void taos_select_call_back(void *param, TAOS_RES *tres, int code);
 void taos_error(TAOS *taos);
 
+static void queryDB(TAOS *taos, char *command) {
+  int i;
+  TAOS_RES *pSql = NULL;
+  int32_t   code = -1;
+
+  for (i = 0; i < 5; i++) {
+    if (NULL != pSql) {
+      taos_free_result(pSql);
+      pSql = NULL;
+    }
+    
+    pSql = taos_query(taos, command);
+    code = taos_errno(pSql);
+    if (0 == code) {
+      break;
+    }    
+  }
+
+  if (code != 0) {
+    fprintf(stderr, "Failed to run %s, reason: %s\n", command, taos_errstr(pSql));
+    taos_free_result(pSql);
+    taos_close(taos);
+    exit(EXIT_FAILURE);
+  }
+
+  taos_free_result(pSql);
+}
+
 int main(int argc, char *argv[])
 {
   TAOS   *taos;
@@ -78,16 +106,14 @@ int main(int argc, char *argv[])
 
   printf("success to connect to server\n");
 
-  sprintf(sql, "drop database %s", db);
-  taos_query(taos, sql);
+  sprintf(sql, "drop database if exists %s", db);
+  queryDB(taos, sql);
 
   sprintf(sql, "create database %s", db);
-  if (taos_query(taos, sql) != 0)
-    taos_error(taos);
+  queryDB(taos, sql);
 
   sprintf(sql, "use %s", db);
-  if (taos_query(taos, sql) != 0)
-    taos_error(taos);
+  queryDB(taos, sql);
 
   strcpy(prefix, "asytbl_");
   for (i = 0; i < numOfTables; ++i) {
@@ -95,8 +121,7 @@ int main(int argc, char *argv[])
     tableList[i].taos = taos;
     sprintf(tableList[i].name, "%s%d", prefix, i);
     sprintf(sql, "create table %s%d (ts timestamp, volume bigint)", prefix, i);
-    if (taos_query(taos, sql) != 0)
-      taos_error(taos);
+    queryDB(taos, sql);
   }  
 
   gettimeofday(&systemTime, NULL);
diff --git a/tests/examples/c/demo.c b/tests/examples/c/demo.c
index 8f8a66a32593bc25d71b554808719ca42f5b32ac..59b9c748277e3d35237018b6885b2b31e6ec5748 100644
--- a/tests/examples/c/demo.c
+++ b/tests/examples/c/demo.c
@@ -22,6 +22,34 @@
 #include <inttypes.h>
 #include <taos.h>  // TAOS header file
 
+static void queryDB(TAOS *taos, char *command) {
+  int i;
+  TAOS_RES *pSql = NULL;
+  int32_t   code = -1;
+
+  for (i = 0; i < 5; i++) {
+    if (NULL != pSql) {
+      taos_free_result(pSql);
+      pSql = NULL;
+    }
+    
+    pSql = taos_query(taos, command);
+    code = taos_errno(pSql);
+    if (0 == code) {
+      break;
+    }    
+  }
+
+  if (code != 0) {
+    fprintf(stderr, "Failed to run %s, reason: %s\n", command, taos_errstr(pSql));
+    taos_free_result(pSql);
+    taos_close(taos);
+    exit(EXIT_FAILURE);
+  }
+
+  taos_free_result(pSql);
+}
+
 int main(int argc, char *argv[]) {
   TAOS *    taos;
   char      qstr[1024];
@@ -44,22 +72,26 @@ int main(int argc, char *argv[]) {
   printf("success to connect to server\n");
 
 
-  taos_query(taos, "drop database demo");
+  //taos_query(taos, "drop database demo");
+  queryDB(taos, "drop database if exists demo");
 
-  result = taos_query(taos, "create database demo");
-  if (result == NULL) {
-    printf("failed to create database, reason:%s\n", "null result"/*taos_errstr(taos)*/);
-    exit(1);
-  }
+  //result = taos_query(taos, "create database demo");
+  //if (result == NULL) {
+  //  printf("failed to create database, reason:%s\n", "null result"/*taos_errstr(taos)*/);
+  //  exit(1);
+  //}
+  queryDB(taos, "create database demo");
   printf("success to create database\n");
 
-  taos_query(taos, "use demo");
+  //taos_query(taos, "use demo");
+  queryDB(taos, "use demo");
 
   // create table
-  if (taos_query(taos, "create table m1 (ts timestamp, ti tinyint, si smallint, i int, bi bigint, f float, d double, b binary(10))") == 0) {
-    printf("failed to create table, reason:%s\n", taos_errstr(result));
-    exit(1);
-  }
+  //if (taos_query(taos, "create table m1 (ts timestamp, ti tinyint, si smallint, i int, bi bigint, f float, d double, b binary(10))") == 0) {
+  //  printf("failed to create table, reason:%s\n", taos_errstr(result));
+  //  exit(1);
+  //}
+  queryDB(taos, "create table m1 (ts timestamp, ti tinyint, si smallint, i int, bi bigint, f float, d double, b binary(10))");
   printf("success to create table\n");
 
   // sleep for one second to make sure table is created on data node
@@ -80,8 +112,10 @@ int main(int argc, char *argv[]) {
       printf("insert row: %i\n", i);
     } else {
       printf("failed to insert row: %i, reason:%s\n", i, "null result"/*taos_errstr(result)*/);
+      taos_free_result(result);
       exit(1);
     }
+    taos_free_result(result);
 
     //sleep(1);
   }
@@ -91,7 +125,8 @@ int main(int argc, char *argv[]) {
   sprintf(qstr, "SELECT * FROM m1");
   result = taos_query(taos, qstr);
   if (result == NULL || taos_errno(result) != 0) {
-    printf("failed to select, reason:%s\n", taos_errstr(result));
+    printf("failed to select, reason:%s\n", taos_errstr(result));    
+    taos_free_result(result);
     exit(1);
   }