Merge pull request #7585 from taosdata/test/TD-6167

[TD-6167]<test> stmt c api test

src/client/src/tscPrepare.c

@@ -86,6 +86,10 @@ typedef struct STscStmt {
   return _code;             \
 } while (0)
 
+#define STMT_CHECK if (pStmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) { \
+                      STMT_RET(TSDB_CODE_TSC_DISCONNECTED);  \
+                    }
+
 static int32_t invalidOperationMsg(char* dstBuffer, const char* errMsg) {
   return tscInvalidOperationMsg(dstBuffer, errMsg, NULL);
 }
@@ -155,6 +159,22 @@ static int normalStmtBindParam(STscStmt* stmt, TAOS_BIND* bind) {
         var->i64 = *(int64_t*)tb->buffer;
         break;
 
+      case  TSDB_DATA_TYPE_UTINYINT:
+        var->u64 = *(uint8_t*)tb->buffer;
+        break;
+
+      case  TSDB_DATA_TYPE_USMALLINT:
+        var->u64 = *(uint16_t*)tb->buffer;
+        break;
+
+      case  TSDB_DATA_TYPE_UINT:
+        var->u64 = *(uint32_t*)tb->buffer;
+        break;
+
+      case  TSDB_DATA_TYPE_UBIGINT:
+        var->u64 = *(uint64_t*)tb->buffer;
+        break;
+
       case TSDB_DATA_TYPE_FLOAT:
         var->dKey = GET_FLOAT_VAL(tb->buffer);
         break;
@@ -261,9 +281,17 @@ static char* normalStmtBuildSql(STscStmt* stmt) {
     case TSDB_DATA_TYPE_SMALLINT:
     case TSDB_DATA_TYPE_INT:
     case TSDB_DATA_TYPE_BIGINT:
+    case TSDB_DATA_TYPE_TIMESTAMP:
       taosStringBuilderAppendInteger(&sb, var->i64);
       break;
 
+    case TSDB_DATA_TYPE_UTINYINT:
+    case TSDB_DATA_TYPE_USMALLINT:
+    case TSDB_DATA_TYPE_UINT:
+    case TSDB_DATA_TYPE_UBIGINT:
+      taosStringBuilderAppendUnsignedInteger(&sb, var->u64);
+      break;
+
     case TSDB_DATA_TYPE_FLOAT:
     case TSDB_DATA_TYPE_DOUBLE:
       taosStringBuilderAppendDouble(&sb, var->dKey);
@@ -1501,9 +1529,7 @@ TAOS_STMT* taos_stmt_init(TAOS* taos) {
 int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) {
   STscStmt* pStmt = (STscStmt*)stmt;
 
-  if (stmt == NULL || pStmt->taos == NULL || pStmt->pSql == NULL) {
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
+  STMT_CHECK
 
   if (sql == NULL) {
     tscError("sql is NULL");
@@ -1580,9 +1606,7 @@ int taos_stmt_set_tbname_tags(TAOS_STMT* stmt, const char* name, TAOS_BIND* tags
   STscStmt* pStmt = (STscStmt*)stmt;
   int32_t code = 0;
 
-  if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
+  STMT_CHECK
 
   SSqlObj* pSql = pStmt->pSql;
   SSqlCmd* pCmd = &pSql->cmd;
@@ -1742,6 +1766,7 @@ int taos_stmt_set_tbname_tags(TAOS_STMT* stmt, const char* name, TAOS_BIND* tags
 
 int taos_stmt_set_sub_tbname(TAOS_STMT* stmt, const char* name) {
   STscStmt* pStmt = (STscStmt*)stmt;
+  STMT_CHECK
   pStmt->mtb.subSet = true;
   return taos_stmt_set_tbname_tags(stmt, name, NULL);
 }
@@ -1750,6 +1775,7 @@ int taos_stmt_set_sub_tbname(TAOS_STMT* stmt, const char* name) {
 
 int taos_stmt_set_tbname(TAOS_STMT* stmt, const char* name) {
   STscStmt* pStmt = (STscStmt*)stmt;
+  STMT_CHECK
   pStmt->mtb.subSet = false;
   return taos_stmt_set_tbname_tags(stmt, name, NULL);
 }
@@ -1757,6 +1783,7 @@ int taos_stmt_set_tbname(TAOS_STMT* stmt, const char* name) {
 
 int taos_stmt_close(TAOS_STMT* stmt) {
   STscStmt* pStmt = (STscStmt*)stmt;
+  STMT_CHECK
   if (!pStmt->isInsert) {
     SNormalStmt* normal = &pStmt->normal;
     if (normal->params != NULL) {
@@ -1785,16 +1812,14 @@ int taos_stmt_close(TAOS_STMT* stmt) {
     }
   }
 
-  taos_free_result(pStmt->pSql);
+  tscFreeSqlObj(pStmt->pSql);
   tfree(pStmt);
   STMT_RET(TSDB_CODE_SUCCESS);
 }
 
 int taos_stmt_bind_param(TAOS_STMT* stmt, TAOS_BIND* bind) {
   STscStmt* pStmt = (STscStmt*)stmt;
-  if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
+  STMT_CHECK
 
   if (pStmt->isInsert) {
     if (pStmt->multiTbInsert) {
@@ -1823,9 +1848,7 @@ int taos_stmt_bind_param(TAOS_STMT* stmt, TAOS_BIND* bind) {
 int taos_stmt_bind_param_batch(TAOS_STMT* stmt, TAOS_MULTI_BIND* bind) {
   STscStmt* pStmt = (STscStmt*)stmt;
 
-  if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
+  STMT_CHECK
 
   if (bind == NULL || bind->num <= 0 || bind->num > INT16_MAX) {
     tscError("0x%"PRIx64" invalid parameter", pStmt->pSql->self);
@@ -1856,9 +1879,7 @@ int taos_stmt_bind_param_batch(TAOS_STMT* stmt, TAOS_MULTI_BIND* bind) {
 
 int taos_stmt_bind_single_param_batch(TAOS_STMT* stmt, TAOS_MULTI_BIND* bind, int colIdx) {
   STscStmt* pStmt = (STscStmt*)stmt;
-  if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
+  STMT_CHECK
 
   if (bind == NULL || bind->num <= 0 || bind->num > INT16_MAX || colIdx < 0) {
     tscError("0x%"PRIx64" invalid parameter", pStmt->pSql->self);
@@ -1891,9 +1912,7 @@ int taos_stmt_bind_single_param_batch(TAOS_STMT* stmt, TAOS_MULTI_BIND* bind, in
 
 int taos_stmt_add_batch(TAOS_STMT* stmt) {
   STscStmt* pStmt = (STscStmt*)stmt;
-  if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
+  STMT_CHECK
 
   if (pStmt->isInsert) {
     if (pStmt->last != STMT_BIND && pStmt->last != STMT_BIND_COL) {
@@ -1920,9 +1939,7 @@ int taos_stmt_reset(TAOS_STMT* stmt) {
 int taos_stmt_execute(TAOS_STMT* stmt) {
   int ret = 0;
   STscStmt* pStmt = (STscStmt*)stmt;
-  if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
+  STMT_CHECK
 
   if (pStmt->isInsert) {
     if (pStmt->last != STMT_ADD_BATCH) {
@@ -1968,18 +1985,14 @@ TAOS_RES *taos_stmt_use_result(TAOS_STMT* stmt) {
     tscError("result has been used already.");
     return NULL;
   }
-
   TAOS_RES* result = pStmt->pSql;
-  pStmt->pSql = NULL;
   return result;
 }
 
 int taos_stmt_is_insert(TAOS_STMT *stmt, int *insert) {
   STscStmt* pStmt = (STscStmt*)stmt;
 
-  if (stmt == NULL || pStmt->taos == NULL || pStmt->pSql == NULL) {
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
+  STMT_CHECK
 
   if (insert) *insert = pStmt->isInsert;
 
@@ -1989,9 +2002,7 @@ int taos_stmt_is_insert(TAOS_STMT *stmt, int *insert) {
 int taos_stmt_num_params(TAOS_STMT *stmt, int *nums) {
   STscStmt* pStmt = (STscStmt*)stmt;
 
-  if (stmt == NULL || pStmt->taos == NULL || pStmt->pSql == NULL) {
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
+  STMT_CHECK
 
   if (pStmt->isInsert) {
     SSqlObj* pSql = pStmt->pSql;
@@ -2008,9 +2019,7 @@ int taos_stmt_num_params(TAOS_STMT *stmt, int *nums) {
 int taos_stmt_get_param(TAOS_STMT *stmt, int idx, int *type, int *bytes) {
   STscStmt* pStmt = (STscStmt*)stmt;
 
-  if (stmt == NULL || pStmt->taos == NULL || pStmt->pSql == NULL) {
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
+  STMT_CHECK
 
   if (pStmt->isInsert) {
     SSqlCmd* pCmd = &pStmt->pSql->cmd;

src/client/src/tscUtil.c

@@ -60,6 +60,21 @@ int32_t converToStr(char *str, int type, void *buf, int32_t bufSize, int32_t *le
     case TSDB_DATA_TYPE_TIMESTAMP:
       n = sprintf(str, "%" PRId64, *(int64_t*)buf);
       break;
+    case TSDB_DATA_TYPE_UTINYINT:
+      n = sprintf(str, "%d", *(uint8_t*)buf);
+      break;
+
+    case TSDB_DATA_TYPE_USMALLINT:
+      n = sprintf(str, "%d", *(uint16_t*)buf);
+      break;
+
+    case TSDB_DATA_TYPE_UINT:
+      n = sprintf(str, "%d", *(uint32_t*)buf);
+      break;
+
+    case TSDB_DATA_TYPE_UBIGINT:
+      n = sprintf(str, "%" PRId64, *(uint64_t*)buf);
+      break;
 
     case TSDB_DATA_TYPE_FLOAT:
       n = sprintf(str, "%f", GET_FLOAT_VAL(buf));

src/util/inc/tstrbuild.h

@@ -43,6 +43,7 @@ void taosStringBuilderAppendStringLen(SStringBuilder* sb, const char* str, size_
 void taosStringBuilderAppendString(SStringBuilder* sb, const char* str);
 void taosStringBuilderAppendNull(SStringBuilder* sb);
 void taosStringBuilderAppendInteger(SStringBuilder* sb, int64_t v);
+void taosStringBuilderAppendUnsignedInteger(SStringBuilder* sb, uint64_t v);
 void taosStringBuilderAppendDouble(SStringBuilder* sb, double v);
 
 #ifdef __cplusplus

src/util/src/tstrbuild.c

@@ -73,6 +73,12 @@ void taosStringBuilderAppendInteger(SStringBuilder* sb, int64_t v) {
   taosStringBuilderAppendStringLen(sb, buf, MIN(len, sizeof(buf)));
 }
 
+void taosStringBuilderAppendUnsignedInteger(SStringBuilder* sb, uint64_t v) {
+  char   buf[64];
+  size_t len = snprintf(buf, sizeof(buf), "%" PRId64, v);
+  taosStringBuilderAppendStringLen(sb, buf, MIN(len, sizeof(buf)));
+}
+
 void taosStringBuilderAppendDouble(SStringBuilder* sb, double v) {
   char   buf[512];
   size_t len = snprintf(buf, sizeof(buf), "%.9lf", v);

tests/examples/c/asyncdemo.c

@@ -20,9 +20,9 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <sys/time.h>
 #include <unistd.h>
-#include <string.h>
 
 #include <taos.h>
 
@@ -33,14 +33,14 @@ int     tablesSelectProcessed = 0;
 int64_t st, et;
 
 typedef struct {
-  int       id;
-  TAOS     *taos;
-  char      name[16];
-  time_t    timeStamp;
-  int       value;
-  int       rowsInserted;
-  int       rowsTried;
-  int       rowsRetrieved;
+  int    id;
+  TAOS * taos;
+  char   name[16];
+  time_t timeStamp;
+  int    value;
+  int    rowsInserted;
+  int    rowsTried;
+  int    rowsRetrieved;
 } STable;
 
 void taos_insert_call_back(void *param, TAOS_RES *tres, int code);
@@ -48,7 +48,7 @@ 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;
+  int       i;
   TAOS_RES *pSql = NULL;
   int32_t   code = -1;
 
@@ -57,12 +57,12 @@ static void queryDB(TAOS *taos, char *command) {
       taos_free_result(pSql);
       pSql = NULL;
     }
-    
+
     pSql = taos_query(taos, command);
     code = taos_errno(pSql);
     if (0 == code) {
       break;
-    }    
+    }
   }
 
   if (code != 0) {
@@ -76,15 +76,14 @@ static void queryDB(TAOS *taos, char *command) {
   taos_free_result(pSql);
 }
 
-int main(int argc, char *argv[])
-{
-  TAOS   *taos;
-  struct  timeval systemTime;
-  int     i;
-  char    sql[1024]  = { 0 };
-  char    prefix[20] = { 0 };
-  char    db[128]    = { 0 };
-  STable *tableList;
+int main(int argc, char *argv[]) {
+  TAOS *         taos;
+  struct timeval systemTime;
+  int            i;
+  char           sql[1024] = {0};
+  char           prefix[20] = {0};
+  char           db[128] = {0};
+  STable *       tableList;
 
   if (argc != 5) {
     printf("usage: %s server-ip dbname rowsPerTable numOfTables\n", argv[0]);
@@ -101,8 +100,7 @@ int main(int argc, char *argv[])
   memset(tableList, 0, size);
 
   taos = taos_connect(argv[1], "root", "taosdata", NULL, 0);
-  if (taos == NULL)
-    taos_error(taos);
+  if (taos == NULL) taos_error(taos);
 
   printf("success to connect to server\n");
 
@@ -122,7 +120,7 @@ int main(int argc, char *argv[])
     sprintf(tableList[i].name, "%s%d", prefix, i);
     sprintf(sql, "create table %s%d (ts timestamp, volume bigint)", prefix, i);
     queryDB(taos, sql);
-  }  
+  }
 
   gettimeofday(&systemTime, NULL);
   for (i = 0; i < numOfTables; ++i)
@@ -138,7 +136,7 @@ int main(int argc, char *argv[])
   tablesInsertProcessed = 0;
   tablesSelectProcessed = 0;
 
-  for (i = 0; i<numOfTables; ++i) {
+  for (i = 0; i < numOfTables; ++i) {
     // insert records in asynchronous API
     sprintf(sql, "insert into %s values(%ld, 0)", tableList[i].name, 1546300800000 + i);
     taos_query_a(taos, sql, taos_insert_call_back, (void *)(tableList + i));
@@ -147,12 +145,12 @@ int main(int argc, char *argv[])
   printf("once insert finished, presse any key to query\n");
   getchar();
 
-  while(1) {
+  while (1) {
     if (tablesInsertProcessed < numOfTables) {
-       printf("wait for process finished\n");
-       sleep(1);
-       continue;
-    }  
+      printf("wait for process finished\n");
+      sleep(1);
+      continue;
+    }
 
     break;
   }
@@ -161,9 +159,8 @@ int main(int argc, char *argv[])
   gettimeofday(&systemTime, NULL);
   st = systemTime.tv_sec * 1000000 + systemTime.tv_usec;
 
-
   for (i = 0; i < numOfTables; ++i) {
-    // select records in asynchronous API 
+    // select records in asynchronous API
     sprintf(sql, "select * from %s", tableList[i].name);
     taos_query_a(taos, sql, taos_select_call_back, (void *)(tableList + i));
   }
@@ -171,17 +168,17 @@ int main(int argc, char *argv[])
   printf("\nonce finished, press any key to exit\n");
   getchar();
 
-  while(1) {
+  while (1) {
     if (tablesSelectProcessed < numOfTables) {
-       printf("wait for process finished\n");
-       sleep(1);
-       continue;
-    }  
+      printf("wait for process finished\n");
+      sleep(1);
+      continue;
+    }
 
     break;
   }
 
-  for (i = 0; i<numOfTables; ++i)  {
+  for (i = 0; i < numOfTables; ++i) {
     printf("%s inserted:%d retrieved:%d\n", tableList[i].name, tableList[i].rowsInserted, tableList[i].rowsRetrieved);
   }
 
@@ -193,60 +190,54 @@ int main(int argc, char *argv[])
   return 0;
 }
 
-void taos_error(TAOS *con)
-{
+void taos_error(TAOS *con) {
   fprintf(stderr, "TDengine error: %s\n", taos_errstr(con));
   taos_close(con);
   taos_cleanup();
   exit(1);
 }
 
-void taos_insert_call_back(void *param, TAOS_RES *tres, int code)
-{
-  STable *pTable = (STable *)param;
-  struct  timeval systemTime;
-  char    sql[128];
+void taos_insert_call_back(void *param, TAOS_RES *tres, int code) {
+  STable *       pTable = (STable *)param;
+  struct timeval systemTime;
+  char           sql[128];
 
   pTable->rowsTried++;
 
-  if (code < 0)  {
+  if (code < 0) {
     printf("%s insert failed, code:%d, rows:%d\n", pTable->name, code, pTable->rowsTried);
-  }
-  else if (code == 0) {
+  } else if (code == 0) {
     printf("%s not inserted\n", pTable->name);
-  }
-  else {
+  } else {
     pTable->rowsInserted++;
   }
 
   if (pTable->rowsTried < points) {
     // for this demo, insert another record
-    sprintf(sql, "insert into %s values(%ld, %d)", pTable->name, 1546300800000+pTable->rowsTried*1000, pTable->rowsTried);
+    sprintf(sql, "insert into %s values(%ld, %d)", pTable->name, 1546300800000 + pTable->rowsTried * 1000,
+            pTable->rowsTried);
     taos_query_a(pTable->taos, sql, taos_insert_call_back, (void *)pTable);
-  }
-  else {
+  } else {
     printf("%d rows data are inserted into %s\n", points, pTable->name);
     tablesInsertProcessed++;
     if (tablesInsertProcessed >= numOfTables) {
       gettimeofday(&systemTime, NULL);
       et = systemTime.tv_sec * 1000000 + systemTime.tv_usec;
-      printf("%lld mseconds to insert %d data points\n", (et - st) / 1000, points*numOfTables);
+      printf("%lld mseconds to insert %d data points\n", (et - st) / 1000, points * numOfTables);
     }
   }
-  
+
   taos_free_result(tres);
 }
 
-void taos_retrieve_call_back(void *param, TAOS_RES *tres, int numOfRows)
-{
-  STable   *pTable = (STable *)param;
+void taos_retrieve_call_back(void *param, TAOS_RES *tres, int numOfRows) {
+  STable *       pTable = (STable *)param;
   struct timeval systemTime;
 
   if (numOfRows > 0) {
-
-    for (int i = 0; i<numOfRows; ++i) {
+    for (int i = 0; i < numOfRows; ++i) {
       // synchronous API to retrieve a row from batch of records
-      /*TAOS_ROW row = */(void)taos_fetch_row(tres);
+      /*TAOS_ROW row = */ (void)taos_fetch_row(tres);
       // process row
     }
 
@@ -255,12 +246,10 @@ void taos_retrieve_call_back(void *param, TAOS_RES *tres, int numOfRows)
     // retrieve next batch of rows
     taos_fetch_rows_a(tres, taos_retrieve_call_back, pTable);
 
-  }
-  else {
-    if (numOfRows < 0)
-      printf("%s retrieve failed, code:%d\n", pTable->name, numOfRows);
+  } else {
+    if (numOfRows < 0) printf("%s retrieve failed, code:%d\n", pTable->name, numOfRows);
 
-    //taos_free_result(tres);
+    // taos_free_result(tres);
     printf("%d rows data retrieved from %s\n", pTable->rowsRetrieved, pTable->name);
 
     tablesSelectProcessed++;
@@ -272,19 +261,15 @@ void taos_retrieve_call_back(void *param, TAOS_RES *tres, int numOfRows)
 
     taos_free_result(tres);
   }
-
-
 }
 
-void taos_select_call_back(void *param, TAOS_RES *tres, int code)
-{
+void taos_select_call_back(void *param, TAOS_RES *tres, int code) {
   STable *pTable = (STable *)param;
 
   if (code == 0 && tres) {
     // asynchronous API to fetch a batch of records
     taos_fetch_rows_a(tres, taos_retrieve_call_back, pTable);
-  }
-  else {
+  } else {
     printf("%s select failed, code:%d\n", pTable->name, code);
     taos_free_result(tres);
     taos_cleanup();

tests/examples/c/demo.c

@@ -16,14 +16,14 @@
 // TAOS standard API example. The same syntax as MySQL, but only a subset
 // to compile: gcc -o demo demo.c -ltaos
 
+#include <inttypes.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <inttypes.h>
 #include <taos.h>  // TAOS header file
 
 static void queryDB(TAOS *taos, char *command) {
-  int i;
+  int       i;
   TAOS_RES *pSql = NULL;
   int32_t   code = -1;
 
@@ -32,12 +32,12 @@ static void queryDB(TAOS *taos, char *command) {
       taos_free_result(pSql);
       pSql = NULL;
     }
-    
+
     pSql = taos_query(taos, command);
     code = taos_errno(pSql);
     if (0 == code) {
       break;
-    }    
+    }
   }
 
   if (code != 0) {
@@ -53,7 +53,7 @@ static void queryDB(TAOS *taos, char *command) {
 void Test(TAOS *taos, char *qstr, int i);
 
 int main(int argc, char *argv[]) {
-  char      qstr[1024];
+  char qstr[1024];
 
   // connect to server
   if (argc < 2) {
@@ -63,7 +63,7 @@ int main(int argc, char *argv[]) {
 
   TAOS *taos = taos_connect(argv[1], "root", "taosdata", NULL, 0);
   if (taos == NULL) {
-    printf("failed to connect to server, reason:%s\n", "null taos"/*taos_errstr(taos)*/);
+    printf("failed to connect to server, reason:%s\n", "null taos" /*taos_errstr(taos)*/);
     exit(1);
   }
   for (int i = 0; i < 100; i++) {
@@ -72,28 +72,30 @@ int main(int argc, char *argv[]) {
   taos_close(taos);
   taos_cleanup();
 }
-void Test(TAOS *taos, char *qstr, int index)  {
+void Test(TAOS *taos, char *qstr, int index) {
   printf("==================test at %d\n================================", index);
   queryDB(taos, "drop database if exists demo");
   queryDB(taos, "create database demo");
   TAOS_RES *result;
   queryDB(taos, "use demo");
 
-  queryDB(taos, "create table m1 (ts timestamp, ti tinyint, si smallint, i int, bi bigint, f float, d double, b binary(10))");
+  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");
 
   int i = 0;
   for (i = 0; i < 10; ++i) {
-    sprintf(qstr, "insert into m1 values (%" PRId64 ", %d, %d, %d, %d, %f, %lf, '%s')", (uint64_t)(1546300800000 + i * 1000), i, i, i, i*10000000, i*1.0, i*2.0, "hello");
+    sprintf(qstr, "insert into m1 values (%" PRId64 ", %d, %d, %d, %d, %f, %lf, '%s')",
+            (uint64_t)(1546300800000 + i * 1000), i, i, i, i * 10000000, i * 1.0, i * 2.0, "hello");
     printf("qstr: %s\n", qstr);
-    
+
     // note: how do you wanna do if taos_query returns non-NULL
     // if (taos_query(taos, qstr)) {
     //   printf("insert row: %i, reason:%s\n", i, taos_errstr(taos));
     // }
     TAOS_RES *result1 = taos_query(taos, qstr);
     if (result1 == NULL || taos_errno(result1) != 0) {
-      printf("failed to insert row, reason:%s\n", taos_errstr(result1));    
+      printf("failed to insert row, reason:%s\n", taos_errstr(result1));
       taos_free_result(result1);
       exit(1);
     } else {
@@ -107,7 +109,7 @@ void Test(TAOS *taos, char *qstr, int index)  {
   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);
   }
@@ -130,4 +132,3 @@ void Test(TAOS *taos, char *qstr, int index)  {
   taos_free_result(result);
   printf("====demo end====\n\n");
 }
-

tests/examples/c/epoll.c

@@ -21,103 +21,101 @@
 
 #ifdef __APPLE__
 #include "osEok.h"
-#else // __APPLE__
+#else  // __APPLE__
 #include <sys/epoll.h>
-#endif // __APPLE__
-#include <sys/types.h>
-#include <sys/time.h>
-#include <sys/socket.h>
-#include <pthread.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <netinet/in.h>
+#endif  // __APPLE__
 #include <arpa/inet.h>
-#include <fcntl.h>
 #include <errno.h>
-#include <string.h>
-#include <arpa/inet.h>
+#include <fcntl.h>
 #include <libgen.h>
 #include <locale.h>
 #include <netdb.h>
+#include <netinet/in.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
 
 #define D(fmt, ...) fprintf(stderr, "%s[%d]%s(): " fmt "\n", basename(__FILE__), __LINE__, __func__, ##__VA_ARGS__)
-#define A(statement, fmt, ...) do {                                     \
-  if (statement) break;                                                 \
-  fprintf(stderr, "%s[%d]%s(): assert [%s] failed: %d[%s]: " fmt "\n",  \
-          basename(__FILE__), __LINE__, __func__,                       \
-          #statement, errno, strerror(errno),                           \
-          ##__VA_ARGS__);                                               \
-  abort();                                                              \
-} while (0)
+#define A(statement, fmt, ...)                                                                                   \
+  do {                                                                                                           \
+    if (statement) break;                                                                                        \
+    fprintf(stderr, "%s[%d]%s(): assert [%s] failed: %d[%s]: " fmt "\n", basename(__FILE__), __LINE__, __func__, \
+            #statement, errno, strerror(errno), ##__VA_ARGS__);                                                  \
+    abort();                                                                                                     \
+  } while (0)
 
-#define E(fmt, ...) do {                                                \
-  fprintf(stderr, "%s[%d]%s(): %d[%s]: " fmt "\n",                      \
-          basename(__FILE__), __LINE__, __func__,                       \
-          errno, strerror(errno),                                       \
-          ##__VA_ARGS__);                                               \
-} while (0)
+#define E(fmt, ...)                                                                                                  \
+  do {                                                                                                               \
+    fprintf(stderr, "%s[%d]%s(): %d[%s]: " fmt "\n", basename(__FILE__), __LINE__, __func__, errno, strerror(errno), \
+            ##__VA_ARGS__);                                                                                          \
+  } while (0)
 
 #include "os.h"
 
-typedef struct ep_s            ep_t;
+typedef struct ep_s ep_t;
 struct ep_s {
-  int                    ep;
+  int ep;
 
-  pthread_mutex_t        lock;
-  int                    sv[2];  // 0 for read, 1 for write;
-  pthread_t              thread;
+  pthread_mutex_t lock;
+  int             sv[2];  // 0 for read, 1 for write;
+  pthread_t       thread;
 
-  volatile unsigned int  stopping:1;
-  volatile unsigned int  waiting:1;
-  volatile unsigned int  wakenup:1;
+  volatile unsigned int stopping : 1;
+  volatile unsigned int waiting : 1;
+  volatile unsigned int wakenup : 1;
 };
 
 static int ep_dummy = 0;
 
-static ep_t* ep_create(void);
+static ep_t *ep_create(void);
 static void  ep_destroy(ep_t *ep);
-static void* routine(void* arg);
-static int open_listen(unsigned short port);
+static void *routine(void *arg);
+static int   open_listen(unsigned short port);
 
-typedef struct fde_s          fde_t;
+typedef struct fde_s fde_t;
 struct fde_s {
-  int                          skt;
+  int skt;
   void (*on_event)(ep_t *ep, struct epoll_event *events, fde_t *client);
 };
 
 static void listen_event(ep_t *ep, struct epoll_event *ev, fde_t *client);
 static void null_event(ep_t *ep, struct epoll_event *ev, fde_t *client);
 
-#define usage(arg0, fmt, ...)       do {                                               \
-  if (fmt[0]) {                                                                        \
-    fprintf(stderr, "" fmt "\n", ##__VA_ARGS__);                                       \
-  }                                                                                    \
-  fprintf(stderr, "usage:\n");                                                         \
-  fprintf(stderr, "  %s -l <port>             : specify listenning port\n", arg0);     \
-} while (0)
+#define usage(arg0, fmt, ...)                                                        \
+  do {                                                                               \
+    if (fmt[0]) {                                                                    \
+      fprintf(stderr, "" fmt "\n", ##__VA_ARGS__);                                   \
+    }                                                                                \
+    fprintf(stderr, "usage:\n");                                                     \
+    fprintf(stderr, "  %s -l <port>             : specify listenning port\n", arg0); \
+  } while (0)
 
 int main(int argc, char *argv[]) {
   char *prg = basename(argv[0]);
-  if (argc==1) {
+  if (argc == 1) {
     usage(prg, "");
     return 0;
   }
-  ep_t* ep = ep_create();
+  ep_t *ep = ep_create();
   A(ep, "failed");
-  for (int i=1; i<argc; ++i) {
+  for (int i = 1; i < argc; ++i) {
     const char *arg = argv[i];
-    if (0==strcmp(arg, "-l")) {
+    if (0 == strcmp(arg, "-l")) {
       ++i;
-      if (i>=argc) {
+      if (i >= argc) {
         usage(prg, "expecting <port> after -l, but got nothing");
-        return 1; // confirmed potential leakage
+        return 1;  // confirmed potential leakage
       }
       arg = argv[i];
       int port = atoi(arg);
       int skt = open_listen(port);
-      if (skt==-1) continue;
-      fde_t *client = (fde_t*)calloc(1, sizeof(*client));
+      if (skt == -1) continue;
+      fde_t *client = (fde_t *)calloc(1, sizeof(*client));
       if (!client) {
         E("out of memory");
         close(skt);
@@ -126,32 +124,32 @@ int main(int argc, char *argv[]) {
       client->skt = skt;
       client->on_event = listen_event;
       struct epoll_event ev = {0};
-      ev.events   = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLRDHUP;
+      ev.events = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLRDHUP;
       ev.data.ptr = client;
-      A(0==epoll_ctl(ep->ep, EPOLL_CTL_ADD, skt, &ev), "");
+      A(0 == epoll_ctl(ep->ep, EPOLL_CTL_ADD, skt, &ev), "");
       continue;
     }
     usage(prg, "unknown argument: [%s]", arg);
     return 1;
   }
-  char *line = NULL;
-  size_t linecap = 0;
+  char *  line = NULL;
+  size_t  linecap = 0;
   ssize_t linelen;
   while ((linelen = getline(&line, &linecap, stdin)) > 0) {
-    line[strlen(line)-1] = '\0';
-    if (0==strcmp(line, "exit")) break;
-    if (0==strcmp(line, "quit")) break;
-    if (line==strstr(line, "close")) {
+    line[strlen(line) - 1] = '\0';
+    if (0 == strcmp(line, "exit")) break;
+    if (0 == strcmp(line, "quit")) break;
+    if (line == strstr(line, "close")) {
       int fd = 0;
       sscanf(line, "close %d", &fd);
-      if (fd<=2) {
+      if (fd <= 2) {
         fprintf(stderr, "fd [%d] invalid\n", fd);
         continue;
       }
-      A(0==epoll_ctl(ep->ep, EPOLL_CTL_DEL, fd, NULL), "");
+      A(0 == epoll_ctl(ep->ep, EPOLL_CTL_DEL, fd, NULL), "");
       continue;
     }
-    if (strlen(line)==0) continue;
+    if (strlen(line) == 0) continue;
     fprintf(stderr, "unknown cmd:[%s]\n", line);
   }
   ep_destroy(ep);
@@ -159,69 +157,69 @@ int main(int argc, char *argv[]) {
   return 0;
 }
 
-ep_t* ep_create(void) {
-  ep_t *ep = (ep_t*)calloc(1, sizeof(*ep));
+ep_t *ep_create(void) {
+  ep_t *ep = (ep_t *)calloc(1, sizeof(*ep));
   A(ep, "out of memory");
-  A(-1!=(ep->ep = epoll_create(1)), "");
+  A(-1 != (ep->ep = epoll_create(1)), "");
   ep->sv[0] = -1;
   ep->sv[1] = -1;
-  A(0==socketpair(AF_LOCAL, SOCK_STREAM, 0, ep->sv), "");
-  A(0==pthread_mutex_init(&ep->lock, NULL), "");
-  A(0==pthread_mutex_lock(&ep->lock), "");
+  A(0 == socketpair(AF_LOCAL, SOCK_STREAM, 0, ep->sv), "");
+  A(0 == pthread_mutex_init(&ep->lock, NULL), "");
+  A(0 == pthread_mutex_lock(&ep->lock), "");
   struct epoll_event ev = {0};
-  ev.events   = EPOLLIN;
+  ev.events = EPOLLIN;
   ev.data.ptr = &ep_dummy;
-  A(0==epoll_ctl(ep->ep, EPOLL_CTL_ADD, ep->sv[0], &ev), "");
-  A(0==pthread_create(&ep->thread, NULL, routine, ep), "");
-  A(0==pthread_mutex_unlock(&ep->lock), "");
+  A(0 == epoll_ctl(ep->ep, EPOLL_CTL_ADD, ep->sv[0], &ev), "");
+  A(0 == pthread_create(&ep->thread, NULL, routine, ep), "");
+  A(0 == pthread_mutex_unlock(&ep->lock), "");
   return ep;
 }
 
 static void ep_destroy(ep_t *ep) {
   A(ep, "invalid argument");
   ep->stopping = 1;
-  A(1==send(ep->sv[1], "1", 1, 0), "");
-  A(0==pthread_join(ep->thread, NULL), "");
-  A(0==pthread_mutex_destroy(&ep->lock), "");
-  A(0==close(ep->sv[0]), "");
-  A(0==close(ep->sv[1]), "");
-  A(0==close(ep->ep), "");
+  A(1 == send(ep->sv[1], "1", 1, 0), "");
+  A(0 == pthread_join(ep->thread, NULL), "");
+  A(0 == pthread_mutex_destroy(&ep->lock), "");
+  A(0 == close(ep->sv[0]), "");
+  A(0 == close(ep->sv[1]), "");
+  A(0 == close(ep->ep), "");
   free(ep);
 }
 
-static void* routine(void* arg) {
+static void *routine(void *arg) {
   A(arg, "invalid argument");
-  ep_t *ep = (ep_t*)arg;
+  ep_t *ep = (ep_t *)arg;
 
   while (!ep->stopping) {
     struct epoll_event evs[10];
     memset(evs, 0, sizeof(evs));
 
-    A(0==pthread_mutex_lock(&ep->lock), "");
-    A(ep->waiting==0, "internal logic error");
+    A(0 == pthread_mutex_lock(&ep->lock), "");
+    A(ep->waiting == 0, "internal logic error");
     ep->waiting = 1;
-    A(0==pthread_mutex_unlock(&ep->lock), "");
+    A(0 == pthread_mutex_unlock(&ep->lock), "");
 
-    int r = epoll_wait(ep->ep, evs, sizeof(evs)/sizeof(evs[0]), -1);
-    A(r>0, "indefinite epoll_wait shall not timeout:[%d]", r);
+    int r = epoll_wait(ep->ep, evs, sizeof(evs) / sizeof(evs[0]), -1);
+    A(r > 0, "indefinite epoll_wait shall not timeout:[%d]", r);
 
-    A(0==pthread_mutex_lock(&ep->lock), "");
-    A(ep->waiting==1, "internal logic error");
+    A(0 == pthread_mutex_lock(&ep->lock), "");
+    A(ep->waiting == 1, "internal logic error");
     ep->waiting = 0;
-    A(0==pthread_mutex_unlock(&ep->lock), "");
+    A(0 == pthread_mutex_unlock(&ep->lock), "");
 
-    for (int i=0; i<r; ++i) {
+    for (int i = 0; i < r; ++i) {
       struct epoll_event *ev = evs + i;
       if (ev->data.ptr == &ep_dummy) {
         char c = '\0';
-        A(1==recv(ep->sv[0], &c, 1, 0), "internal logic error");
-        A(0==pthread_mutex_lock(&ep->lock), "");
+        A(1 == recv(ep->sv[0], &c, 1, 0), "internal logic error");
+        A(0 == pthread_mutex_lock(&ep->lock), "");
         ep->wakenup = 0;
-        A(0==pthread_mutex_unlock(&ep->lock), "");
+        A(0 == pthread_mutex_unlock(&ep->lock), "");
         continue;
       }
       A(ev->data.ptr, "internal logic error");
-      fde_t *client = (fde_t*)ev->data.ptr;
+      fde_t *client = (fde_t *)ev->data.ptr;
       client->on_event(ep, ev, client);
       continue;
     }
@@ -232,7 +230,7 @@ static void* routine(void* arg) {
 static int open_listen(unsigned short port) {
   int r = 0;
   int skt = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-  if (skt==-1) {
+  if (skt == -1) {
     E("socket() failed");
     return -1;
   }
@@ -241,7 +239,7 @@ static int open_listen(unsigned short port) {
     si.sin_family = AF_INET;
     si.sin_addr.s_addr = inet_addr("0.0.0.0");
     si.sin_port = htons(port);
-    r = bind(skt, (struct sockaddr*)&si, sizeof(si));
+    r = bind(skt, (struct sockaddr *)&si, sizeof(si));
     if (r) {
       E("bind(%u) failed", port);
       break;
@@ -257,7 +255,7 @@ static int open_listen(unsigned short port) {
     if (r) {
       E("getsockname() failed");
     }
-    A(len==sizeof(si), "internal logic error");
+    A(len == sizeof(si), "internal logic error");
     D("listenning at: %d", ntohs(si.sin_port));
     return skt;
   } while (0);
@@ -268,10 +266,10 @@ static int open_listen(unsigned short port) {
 static void listen_event(ep_t *ep, struct epoll_event *ev, fde_t *client) {
   A(ev->events & EPOLLIN, "internal logic error");
   struct sockaddr_in si = {0};
-  socklen_t silen = sizeof(si);
-  int skt = accept(client->skt, (struct sockaddr*)&si, &silen);
-  A(skt!=-1, "internal logic error");
-  fde_t *server = (fde_t*)calloc(1, sizeof(*server));
+  socklen_t          silen = sizeof(si);
+  int                skt = accept(client->skt, (struct sockaddr *)&si, &silen);
+  A(skt != -1, "internal logic error");
+  fde_t *server = (fde_t *)calloc(1, sizeof(*server));
   if (!server) {
     close(skt);
     return;
@@ -279,26 +277,25 @@ static void listen_event(ep_t *ep, struct epoll_event *ev, fde_t *client) {
   server->skt = skt;
   server->on_event = null_event;
   struct epoll_event ee = {0};
-  ee.events   = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLRDHUP;
+  ee.events = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLRDHUP;
   ee.data.ptr = server;
-  A(0==epoll_ctl(ep->ep, EPOLL_CTL_ADD, skt, &ee), "");
+  A(0 == epoll_ctl(ep->ep, EPOLL_CTL_ADD, skt, &ee), "");
 }
 
 static void null_event(ep_t *ep, struct epoll_event *ev, fde_t *client) {
   if (ev->events & EPOLLIN) {
     char buf[8192];
-    int n = recv(client->skt, buf, sizeof(buf), 0);
-    A(n>=0 && n<=sizeof(buf), "internal logic error:[%d]", n);
-    A(n==fwrite(buf, 1, n, stdout), "internal logic error");
+    int  n = recv(client->skt, buf, sizeof(buf), 0);
+    A(n >= 0 && n <= sizeof(buf), "internal logic error:[%d]", n);
+    A(n == fwrite(buf, 1, n, stdout), "internal logic error");
   }
   if (ev->events & (EPOLLERR | EPOLLHUP | EPOLLRDHUP)) {
-    A(0==pthread_mutex_lock(&ep->lock), "");
-    A(0==epoll_ctl(ep->ep, EPOLL_CTL_DEL, client->skt, NULL), "");
-    A(0==pthread_mutex_unlock(&ep->lock), "");
+    A(0 == pthread_mutex_lock(&ep->lock), "");
+    A(0 == epoll_ctl(ep->ep, EPOLL_CTL_DEL, client->skt, NULL), "");
+    A(0 == pthread_mutex_unlock(&ep->lock), "");
     close(client->skt);
     client->skt = -1;
     client->on_event = NULL;
     free(client);
   }
 }
-

tests/examples/c/makefile

@@ -7,6 +7,7 @@ LFLAGS = '-Wl,-rpath,/usr/local/taos/driver/' -ltaos -lpthread -lm -lrt
 CFLAGS = -O3 -g -Wall -Wno-deprecated -fPIC -Wno-unused-result -Wconversion \
 	-Wno-char-subscripts -D_REENTRANT -Wno-format -D_REENTRANT -DLINUX \
 	-Wno-unused-function -D_M_X64 -I/usr/local/taos/include -std=gnu99
+	-fsanitize=address -fsanitize=undefined -fno-sanitize-recover=all -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fno-sanitize=null -fno-sanitize=alignment
 
 all: $(TARGET)
 
@@ -19,10 +20,9 @@ exe:
 	gcc $(CFLAGS) ./apitest.c -o $(ROOT)apitest $(LFLAGS)
 
 clean:
-	rm $(ROOT)asyncdemo
-	rm $(ROOT)demo
-	rm $(ROOT)prepare
-	rm $(ROOT)batchprepare
-	rm $(ROOT)stream
-	rm $(ROOT)subscribe
-	rm $(ROOT)apitest
+	rm -f $(ROOT)asyncdemo
+	rm -f $(ROOT)demo
+	rm -f $(ROOT)prepare
+	rm -f $(ROOT)stream
+	rm -f $(ROOT)subscribe
+	rm -f $(ROOT)apitest

tests/examples/c/schemaless.c

+#include "os.h"
 #include "taos.h"
 #include "taoserror.h"
-#include "os.h"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -12,15 +12,12 @@ int numSuperTables = 8;
 int numChildTables = 4;
 int numRowsPerChildTable = 2048;
 
-void shuffle(char**lines, size_t n)
-{
-  if (n > 1)
-  {
+void shuffle(char** lines, size_t n) {
+  if (n > 1) {
     size_t i;
-    for (i = 0; i < n - 1; i++)
-    {
+    for (i = 0; i < n - 1; i++) {
       size_t j = i + rand() / (RAND_MAX / (n - i) + 1);
-      char* t = lines[j];
+      char*  t = lines[j];
       lines[j] = lines[i];
       lines[i] = t;
     }
@@ -34,7 +31,7 @@ static int64_t getTimeInUs() {
 }
 
 int main(int argc, char* argv[]) {
-  TAOS_RES *result;
+  TAOS_RES*   result;
   const char* host = "127.0.0.1";
   const char* user = "root";
   const char* passwd = "taosdata";
@@ -59,12 +56,16 @@ int main(int argc, char* argv[]) {
 
   (void)taos_select_db(taos, "db");
 
-  time_t ct = time(0);
+  time_t  ct = time(0);
   int64_t ts = ct * 1000;
-  char* lineFormat = "sta%d,t0=true,t1=127i8,t2=32767i16,t3=%di32,t4=9223372036854775807i64,t9=11.12345f32,t10=22.123456789f64,t11=\"binaryTagValue\",t12=L\"ncharTagValue\" c0=true,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=255u8,c6=32770u16,c7=2147483699u32,c8=9223372036854775899u64,c9=11.12345f32,c10=22.123456789f64,c11=\"binaryValue\",c12=L\"ncharValue\" %lldms";
+  char*   lineFormat =
+      "sta%d,t0=true,t1=127i8,t2=32767i16,t3=%di32,t4=9223372036854775807i64,t9=11.12345f32,t10=22.123456789f64,t11="
+      "\"binaryTagValue\",t12=L\"ncharTagValue\" "
+      "c0=true,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=255u8,c6=32770u16,c7=2147483699u32,"
+      "c8=9223372036854775899u64,c9=11.12345f32,c10=22.123456789f64,c11=\"binaryValue\",c12=L\"ncharValue\" %lldms";
 
   char** lines = calloc(numSuperTables * numChildTables * numRowsPerChildTable, sizeof(char*));
-  int l = 0;
+  int    l = 0;
   for (int i = 0; i < numSuperTables; ++i) {
     for (int j = 0; j < numChildTables; ++j) {
       for (int k = 0; k < numRowsPerChildTable; ++k) {
@@ -78,121 +79,142 @@ int main(int argc, char* argv[]) {
   shuffle(lines, numSuperTables * numChildTables * numRowsPerChildTable);
 
   printf("%s\n", "begin taos_insert_lines");
-  int64_t  begin = getTimeInUs();
+  int64_t begin = getTimeInUs();
   int32_t code = taos_insert_lines(taos, lines, numSuperTables * numChildTables * numRowsPerChildTable);
   int64_t end = getTimeInUs();
-  printf("code: %d, %s. time used: %"PRId64"\n", code, tstrerror(code), end-begin);
+  printf("code: %d, %s. time used: %" PRId64 "\n", code, tstrerror(code), end - begin);
 
   char* lines_000_0[] = {
-      "sta1,id=sta1_1,t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=255u8,t6=32770u16,t7=2147483699u32,t8=9223372036854775899u64,t9=11.12345f32,t10=22.123456789f64,t11=\"binaryTagValue\",t12=L\"ncharTagValue\" c0=true,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=255u8,c6=32770u16,c7=2147483699u32,c8=9223372036854775899u64,c9=11.12345f32,c10=22.123456789f64,c11=\"binaryValue\",c12=L\"ncharValue\" 1626006833639000us"
-  };
-
-  code = taos_insert_lines(taos, lines_000_0 , sizeof(lines_000_0)/sizeof(char*));
+      "sta1,id=sta1_1,t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=255u8,t6=32770u16,t7="
+      "2147483699u32,t8=9223372036854775899u64,t9=11.12345f32,t10=22.123456789f64,t11=\"binaryTagValue\",t12="
+      "L\"ncharTagValue\" "
+      "c0=true,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=255u8,c6=32770u16,c7=2147483699u32,"
+      "c8=9223372036854775899u64,c9=11.12345f32,c10=22.123456789f64,c11=\"binaryValue\",c12=L\"ncharValue\" "
+      "1626006833639000us"};
+
+  code = taos_insert_lines(taos, lines_000_0, sizeof(lines_000_0) / sizeof(char*));
   if (0 == code) {
     printf("taos_insert_lines() lines_000_0 should return error\n");
     return -1;
   }
 
   char* lines_000_1[] = {
-      "sta2,id=\"sta2_1\",t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=255u8,t6=32770u16,t7=2147483699u32,t8=9223372036854775899u64,t9=11.12345f32,t10=22.123456789f64,t11=\"binaryTagValue\",t12=L\"ncharTagValue\" c0=true,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=255u8,c6=32770u16,c7=2147483699u32,c8=9223372036854775899u64,c9=11.12345f32,c10=22.123456789f64,c11=\"binaryValue\",c12=L\"ncharValue\" 1626006833639001"
-  };
-
-  code = taos_insert_lines(taos, lines_000_1 , sizeof(lines_000_1)/sizeof(char*));
+      "sta2,id=\"sta2_1\",t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=255u8,t6=32770u16,"
+      "t7=2147483699u32,t8=9223372036854775899u64,t9=11.12345f32,t10=22.123456789f64,t11=\"binaryTagValue\",t12="
+      "L\"ncharTagValue\" "
+      "c0=true,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=255u8,c6=32770u16,c7=2147483699u32,"
+      "c8=9223372036854775899u64,c9=11.12345f32,c10=22.123456789f64,c11=\"binaryValue\",c12=L\"ncharValue\" "
+      "1626006833639001"};
+
+  code = taos_insert_lines(taos, lines_000_1, sizeof(lines_000_1) / sizeof(char*));
   if (0 == code) {
     printf("taos_insert_lines() lines_000_1 should return error\n");
     return -1;
   }
 
   char* lines_000_2[] = {
-      "sta3,id=\"sta3_1\",t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t9=11.12345f32,t10=22.123456789f64,t11=\"binaryTagValue\",t12=L\"ncharTagValue\" c0=true,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=255u8,c6=32770u16,c7=2147483699u32,c8=9223372036854775899u64,c9=11.12345f32,c10=22.123456789f64,c11=\"binaryValue\",c12=L\"ncharValue\" 0"
-  };
+      "sta3,id=\"sta3_1\",t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t9=11.12345f32,t10="
+      "22.123456789f64,t11=\"binaryTagValue\",t12=L\"ncharTagValue\" "
+      "c0=true,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=255u8,c6=32770u16,c7=2147483699u32,"
+      "c8=9223372036854775899u64,c9=11.12345f32,c10=22.123456789f64,c11=\"binaryValue\",c12=L\"ncharValue\" 0"};
 
-  code = taos_insert_lines(taos, lines_000_2 , sizeof(lines_000_2)/sizeof(char*));
+  code = taos_insert_lines(taos, lines_000_2, sizeof(lines_000_2) / sizeof(char*));
   if (0 != code) {
     printf("taos_insert_lines() lines_000_2 return code:%d (%s)\n", code, (char*)tstrerror(code));
     return -1;
   }
 
   char* lines_001_0[] = {
-      "sta4,t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t9=11.12345f32,t10=22.123456789f64,t11=\"binaryTagValue\",t12=L\"ncharTagValue\" c0=true,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c9=11.12345f32,c10=22.123456789f64,c11=\"binaryValue\",c12=L\"ncharValue\" 1626006833639000us",
+      "sta4,t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t9=11.12345f32,t10=22.123456789f64,"
+      "t11=\"binaryTagValue\",t12=L\"ncharTagValue\" "
+      "c0=true,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c9=11.12345f32,c10=22.123456789f64,c11="
+      "\"binaryValue\",c12=L\"ncharValue\" 1626006833639000us",
 
   };
 
-  code = taos_insert_lines(taos, lines_001_0 , sizeof(lines_001_0)/sizeof(char*));
+  code = taos_insert_lines(taos, lines_001_0, sizeof(lines_001_0) / sizeof(char*));
   if (0 != code) {
     printf("taos_insert_lines() lines_001_0 return code:%d (%s)\n", code, (char*)tstrerror(code));
     return -1;
   }
 
   char* lines_001_1[] = {
-      "sta5,id=\"sta5_1\",t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t9=11.12345f32,t10=22.123456789f64,t11=\"binaryTagValue\",t12=L\"ncharTagValue\" c0=true,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c9=11.12345f32,c10=22.123456789f64,c11=\"binaryValue\",c12=L\"ncharValue\" 1626006833639001"
-  };
+      "sta5,id=\"sta5_1\",t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t9=11.12345f32,t10="
+      "22.123456789f64,t11=\"binaryTagValue\",t12=L\"ncharTagValue\" "
+      "c0=true,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c9=11.12345f32,c10=22.123456789f64,c11="
+      "\"binaryValue\",c12=L\"ncharValue\" 1626006833639001"};
 
-  code = taos_insert_lines(taos, lines_001_1 , sizeof(lines_001_1)/sizeof(char*));
+  code = taos_insert_lines(taos, lines_001_1, sizeof(lines_001_1) / sizeof(char*));
   if (0 != code) {
     printf("taos_insert_lines() lines_001_1 return code:%d (%s)\n", code, (char*)tstrerror(code));
     return -1;
   }
 
   char* lines_001_2[] = {
-      "sta6,id=\"sta6_1\",t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t9=11.12345f32,t10=22.123456789f64,t11=\"binaryTagValue\",t12=L\"ncharTagValue\" c0=true,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c9=11.12345f32,c10=22.123456789f64,c11=\"binaryValue\",c12=L\"ncharValue\" 0"
-  };
+      "sta6,id=\"sta6_1\",t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t9=11.12345f32,t10="
+      "22.123456789f64,t11=\"binaryTagValue\",t12=L\"ncharTagValue\" "
+      "c0=true,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c9=11.12345f32,c10=22.123456789f64,c11="
+      "\"binaryValue\",c12=L\"ncharValue\" 0"};
 
-  code = taos_insert_lines(taos, lines_001_2 , sizeof(lines_001_2)/sizeof(char*));
+  code = taos_insert_lines(taos, lines_001_2, sizeof(lines_001_2) / sizeof(char*));
   if (0 != code) {
     printf("taos_insert_lines() lines_001_2 return code:%d (%s)\n", code, (char*)tstrerror(code));
     return -1;
   }
 
   char* lines_002[] = {
-      "stb,id=\"stb_1\",t20=t,t21=T,t22=true,t23=True,t24=TRUE,t25=f,t26=F,t27=false,t28=False,t29=FALSE,t10=33.12345,t11=\"binaryTagValue\",t12=L\"ncharTagValue\" c20=t,c21=T,c22=true,c23=True,c24=TRUE,c25=f,c26=F,c27=false,c28=False,c29=FALSE,c10=33.12345,c11=\"binaryValue\",c12=L\"ncharValue\" 1626006833639000000ns",
-      "stc,id=\"stc_1\",t20=t,t21=T,t22=true,t23=True,t24=TRUE,t25=f,t26=F,t27=false,t28=False,t29=FALSE,t10=33.12345,t11=\"binaryTagValue\",t12=L\"ncharTagValue\" c20=t,c21=T,c22=true,c23=True,c24=TRUE,c25=f,c26=F,c27=false,c28=False,c29=FALSE,c10=33.12345,c11=\"binaryValue\",c12=L\"ncharValue\" 1626006833639019us",
-      "stc,id=\"stc_1\",t20=t,t21=T,t22=true,t23=True,t24=TRUE,t25=f,t26=F,t27=false,t28=False,t29=FALSE,t10=33.12345,t11=\"binaryTagValue\",t12=L\"ncharTagValue\" c20=t,c21=T,c22=true,c23=True,c24=TRUE,c25=f,c26=F,c27=false,c28=False,c29=FALSE,c10=33.12345,c11=\"binaryValue\",c12=L\"ncharValue\" 1626006833640ms",
-      "stc,id=\"stc_1\",t20=t,t21=T,t22=true,t23=True,t24=TRUE,t25=f,t26=F,t27=false,t28=False,t29=FALSE,t10=33.12345,t11=\"binaryTagValue\",t12=L\"ncharTagValue\" c20=t,c21=T,c22=true,c23=True,c24=TRUE,c25=f,c26=F,c27=false,c28=False,c29=FALSE,c10=33.12345,c11=\"binaryValue\",c12=L\"ncharValue\" 1626006834s"
-  };
-
-  code = taos_insert_lines(taos, lines_002 , sizeof(lines_002)/sizeof(char*));
+      "stb,id=\"stb_1\",t20=t,t21=T,t22=true,t23=True,t24=TRUE,t25=f,t26=F,t27=false,t28=False,t29=FALSE,t10=33.12345,"
+      "t11=\"binaryTagValue\",t12=L\"ncharTagValue\" "
+      "c20=t,c21=T,c22=true,c23=True,c24=TRUE,c25=f,c26=F,c27=false,c28=False,c29=FALSE,c10=33.12345,c11="
+      "\"binaryValue\",c12=L\"ncharValue\" 1626006833639000000ns",
+      "stc,id=\"stc_1\",t20=t,t21=T,t22=true,t23=True,t24=TRUE,t25=f,t26=F,t27=false,t28=False,t29=FALSE,t10=33.12345,"
+      "t11=\"binaryTagValue\",t12=L\"ncharTagValue\" "
+      "c20=t,c21=T,c22=true,c23=True,c24=TRUE,c25=f,c26=F,c27=false,c28=False,c29=FALSE,c10=33.12345,c11="
+      "\"binaryValue\",c12=L\"ncharValue\" 1626006833639019us",
+      "stc,id=\"stc_1\",t20=t,t21=T,t22=true,t23=True,t24=TRUE,t25=f,t26=F,t27=false,t28=False,t29=FALSE,t10=33.12345,"
+      "t11=\"binaryTagValue\",t12=L\"ncharTagValue\" "
+      "c20=t,c21=T,c22=true,c23=True,c24=TRUE,c25=f,c26=F,c27=false,c28=False,c29=FALSE,c10=33.12345,c11="
+      "\"binaryValue\",c12=L\"ncharValue\" 1626006833640ms",
+      "stc,id=\"stc_1\",t20=t,t21=T,t22=true,t23=True,t24=TRUE,t25=f,t26=F,t27=false,t28=False,t29=FALSE,t10=33.12345,"
+      "t11=\"binaryTagValue\",t12=L\"ncharTagValue\" "
+      "c20=t,c21=T,c22=true,c23=True,c24=TRUE,c25=f,c26=F,c27=false,c28=False,c29=FALSE,c10=33.12345,c11="
+      "\"binaryValue\",c12=L\"ncharValue\" 1626006834s"};
+
+  code = taos_insert_lines(taos, lines_002, sizeof(lines_002) / sizeof(char*));
   if (0 != code) {
     printf("taos_insert_lines() lines_002 return code:%d (%s)\n", code, (char*)tstrerror(code));
     return -1;
   }
 
-  //Duplicate key check;
-  char* lines_003_1[] = {
-      "std,id=\"std_3_1\",t1=4i64,Id=\"std\",t2=true c1=true 1626006834s"
-  };
+  // Duplicate key check;
+  char* lines_003_1[] = {"std,id=\"std_3_1\",t1=4i64,Id=\"std\",t2=true c1=true 1626006834s"};
 
-  code = taos_insert_lines(taos, lines_003_1 , sizeof(lines_003_1)/sizeof(char*));
+  code = taos_insert_lines(taos, lines_003_1, sizeof(lines_003_1) / sizeof(char*));
   if (0 == code) {
     printf("taos_insert_lines() lines_003_1 return code:%d (%s)\n", code, (char*)tstrerror(code));
     return -1;
   }
 
-  char* lines_003_2[] = {
-      "std,id=\"std_3_2\",tag1=4i64,Tag2=true,tAg3=2,TaG2=\"dup!\" c1=true 1626006834s"
-  };
+  char* lines_003_2[] = {"std,id=\"std_3_2\",tag1=4i64,Tag2=true,tAg3=2,TaG2=\"dup!\" c1=true 1626006834s"};
 
-  code = taos_insert_lines(taos, lines_003_2 , sizeof(lines_003_2)/sizeof(char*));
+  code = taos_insert_lines(taos, lines_003_2, sizeof(lines_003_2) / sizeof(char*));
   if (0 == code) {
     printf("taos_insert_lines() lines_003_2 return code:%d (%s)\n", code, (char*)tstrerror(code));
     return -1;
   }
 
-  char* lines_003_3[] = {
-      "std,id=\"std_3_3\",tag1=4i64 field1=true,Field2=2,FIElD1=\"dup!\",fIeLd4=true 1626006834s"
-  };
+  char* lines_003_3[] = {"std,id=\"std_3_3\",tag1=4i64 field1=true,Field2=2,FIElD1=\"dup!\",fIeLd4=true 1626006834s"};
 
-  code = taos_insert_lines(taos, lines_003_3 , sizeof(lines_003_3)/sizeof(char*));
+  code = taos_insert_lines(taos, lines_003_3, sizeof(lines_003_3) / sizeof(char*));
   if (0 == code) {
     printf("taos_insert_lines() lines_003_3 return code:%d (%s)\n", code, (char*)tstrerror(code));
     return -1;
   }
 
   char* lines_003_4[] = {
-      "std,id=\"std_3_4\",tag1=4i64,dupkey=4i16,tag2=T field1=true,dUpkEy=1e3f32,field2=\"1234\" 1626006834s"
-  };
+      "std,id=\"std_3_4\",tag1=4i64,dupkey=4i16,tag2=T field1=true,dUpkEy=1e3f32,field2=\"1234\" 1626006834s"};
 
-  code = taos_insert_lines(taos, lines_003_4 , sizeof(lines_003_4)/sizeof(char*));
+  code = taos_insert_lines(taos, lines_003_4, sizeof(lines_003_4) / sizeof(char*));
   if (0 == code) {
     printf("taos_insert_lines() lines_003_4 return code:%d (%s)\n", code, (char*)tstrerror(code));
     return -1;

tests/examples/c/stream.c

@@ -13,24 +13,23 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <pthread.h>
-#include <unistd.h>
 #include <taos.h>  // include TDengine header file
+#include <unistd.h>
 
 typedef struct {
-	char  server_ip[64];
-    char  db_name[64];
-    char  tbl_name[64];
+  char server_ip[64];
+  char db_name[64];
+  char tbl_name[64];
 } param;
 
-int g_thread_exit_flag = 0;
-void* insert_rows(void *sarg);
+int   g_thread_exit_flag = 0;
+void *insert_rows(void *sarg);
 
-void streamCallBack(void *param, TAOS_RES *res, TAOS_ROW row)
-{
+void streamCallBack(void *param, TAOS_RES *res, TAOS_ROW row) {
   // in this simple demo, it just print out the result
   char temp[128];
 
@@ -42,85 +41,81 @@ void streamCallBack(void *param, TAOS_RES *res, TAOS_ROW row)
   printf("\n%s\n", temp);
 }
 
-int main(int argc, char *argv[]) 
-{
-  TAOS       *taos;
-  char        db_name[64];
-  char        tbl_name[64];
-  char        sql[1024] = { 0 };
+int main(int argc, char *argv[]) {
+  TAOS *taos;
+  char  db_name[64];
+  char  tbl_name[64];
+  char  sql[1024] = {0};
 
   if (argc != 4) {
     printf("usage: %s server-ip dbname tblname\n", argv[0]);
     exit(0);
-  } 
+  }
 
   strcpy(db_name, argv[2]);
   strcpy(tbl_name, argv[3]);
-  
+
   // create pthread to insert into row per second for stream calc
   param *t_param = (param *)malloc(sizeof(param));
-  if (NULL == t_param)
-  {
+  if (NULL == t_param) {
     printf("failed to malloc\n");
     exit(1);
   }
-  memset(t_param, 0, sizeof(param)); 
+  memset(t_param, 0, sizeof(param));
   strcpy(t_param->server_ip, argv[1]);
   strcpy(t_param->db_name, db_name);
   strcpy(t_param->tbl_name, tbl_name);
 
   pthread_t pid;
-  pthread_create(&pid, NULL, (void * (*)(void *))insert_rows, t_param);
+  pthread_create(&pid, NULL, (void *(*)(void *))insert_rows, t_param);
 
-  sleep(3); // waiting for database is created.
+  sleep(3);  // waiting for database is created.
   // open connection to database
   taos = taos_connect(argv[1], "root", "taosdata", db_name, 0);
   if (taos == NULL) {
     printf("failed to connet to server:%s\n", argv[1]);
-	  free(t_param);
+    free(t_param);
     exit(1);
   }
 
-  // starting stream calc, 
+  // starting stream calc,
   printf("please input stream SQL:[e.g., select count(*) from tblname interval(5s) sliding(2s);]\n");
   fgets(sql, sizeof(sql), stdin);
   if (sql[0] == 0) {
-    printf("input NULL stream SQL, so exit!\n");	
+    printf("input NULL stream SQL, so exit!\n");
     free(t_param);
     exit(1);
   }
 
-  // param is set to NULL in this demo, it shall be set to the pointer to app context 
+  // param is set to NULL in this demo, it shall be set to the pointer to app context
   TAOS_STREAM *pStream = taos_open_stream(taos, sql, streamCallBack, 0, NULL, NULL);
   if (NULL == pStream) {
-    printf("failed to create stream\n");	
+    printf("failed to create stream\n");
     free(t_param);
     exit(1);
   }
-  
+
   printf("presss any key to exit\n");
   getchar();
 
   taos_close_stream(pStream);
-  
-  g_thread_exit_flag = 1;  
+
+  g_thread_exit_flag = 1;
   pthread_join(pid, NULL);
 
   taos_close(taos);
-  free(t_param); 
+  free(t_param);
 
   return 0;
 }
 
+void *insert_rows(void *sarg) {
+  TAOS * taos;
+  char   command[1024] = {0};
+  param *winfo = (param *)sarg;
 
-void* insert_rows(void *sarg)
-{
-  TAOS  *taos;
-  char    command[1024] = { 0 };
-  param  *winfo = (param * )sarg;
-
-  if (NULL == winfo){
-  	printf("para is null!\n");
+  if (NULL == winfo) {
+    printf("para is null!\n");
     exit(1);
   }
 
@@ -129,7 +124,7 @@ void* insert_rows(void *sarg)
     printf("failed to connet to server:%s\n", winfo->server_ip);
     exit(1);
   }
-  
+
   // drop database
   sprintf(command, "drop database %s;", winfo->db_name);
   if (taos_query(taos, command) != 0) {
@@ -160,19 +155,18 @@ void* insert_rows(void *sarg)
 
   // insert data
   int64_t begin = (int64_t)time(NULL);
-  int index = 0;
+  int     index = 0;
   while (1) {
     if (g_thread_exit_flag) break;
-	
+
     index++;
     sprintf(command, "insert into %s values (%ld, %d)", winfo->tbl_name, (begin + index) * 1000, index);
     if (taos_query(taos, command)) {
       printf("failed to insert row [%s], reason:%s\n", command, taos_errstr(taos));
     }
     sleep(1);
-  }  
+  }
 
   taos_close(taos);
   return 0;
 }
-

tests/examples/c/subscribe.c

@@ -14,10 +14,10 @@ void print_result(TAOS_RES* res, int blockFetch) {
   int         num_fields = taos_num_fields(res);
   TAOS_FIELD* fields = taos_fetch_fields(res);
   int         nRows = 0;
-  
+
   if (blockFetch) {
     nRows = taos_fetch_block(res, &row);
-    //for (int i = 0; i < nRows; i++) {
+    // for (int i = 0; i < nRows; i++) {
     //  taos_print_row(buf, row + i, fields, num_fields);
     //  puts(buf);
     //}
@@ -34,15 +34,11 @@ void print_result(TAOS_RES* res, int blockFetch) {
   printf("%d rows consumed.\n", nRows);
 }
 
-
-void subscribe_callback(TAOS_SUB* tsub, TAOS_RES *res, void* param, int code) {
-  print_result(res, *(int*)param);
-}
-
+void subscribe_callback(TAOS_SUB* tsub, TAOS_RES* res, void* param, int code) { print_result(res, *(int*)param); }
 
 void check_row_count(int line, TAOS_RES* res, int expected) {
-  int actual = 0;
-  TAOS_ROW    row;
+  int      actual = 0;
+  TAOS_ROW row;
   while ((row = taos_fetch_row(res))) {
     actual++;
   }
@@ -53,16 +49,14 @@ void check_row_count(int line, TAOS_RES* res, int expected) {
   }
 }
 
-
 void do_query(TAOS* taos, const char* sql) {
   TAOS_RES* res = taos_query(taos, sql);
   taos_free_result(res);
 }
 
-
 void run_test(TAOS* taos) {
   do_query(taos, "drop database if exists test;");
-  
+
   usleep(100000);
   do_query(taos, "create database test;");
   usleep(100000);
@@ -161,14 +155,13 @@ void run_test(TAOS* taos) {
   taos_unsubscribe(tsub, 0);
 }
 
-
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
   const char* host = "127.0.0.1";
   const char* user = "root";
   const char* passwd = "taosdata";
   const char* sql = "select * from meters;";
   const char* topic = "test-multiple";
-  int async = 1, restart = 0, keep = 1, test = 0, blockFetch = 0;
+  int         async = 1, restart = 0, keep = 1, test = 0, blockFetch = 0;
 
   for (int i = 1; i < argc; i++) {
     if (strncmp(argv[i], "-h=", 3) == 0) {
@@ -240,20 +233,21 @@ int main(int argc, char *argv[]) {
   if (tsub == NULL) {
     printf("failed to create subscription.\n");
     exit(0);
-  } 
+  }
 
   if (async) {
     getchar();
-  } else while(1) {
-    TAOS_RES* res = taos_consume(tsub);
-    if (res == NULL) {
-      printf("failed to consume data.");
-      break;
-    } else {
-      print_result(res, blockFetch);
-      getchar();
+  } else
+    while (1) {
+      TAOS_RES* res = taos_consume(tsub);
+      if (res == NULL) {
+        printf("failed to consume data.");
+        break;
+      } else {
+        print_result(res, blockFetch);
+        getchar();
+      }
     }
-  }
 
   printf("total rows consumed: %d\n", nTotalRows);
   taos_unsubscribe(tsub, keep);

tests/script/api/makefile

@@ -7,7 +7,7 @@ LFLAGS = '-Wl,-rpath,/usr/local/taos/driver/' -ltaos -lpthread -lm -lrt
 CFLAGS = -O0 -g -Wall -Wno-deprecated -fPIC -Wno-unused-result -Wconversion \
 	-Wno-char-subscripts -D_REENTRANT -Wno-format -D_REENTRANT -DLINUX \
 	-Wno-unused-function -D_M_X64 -I/usr/local/taos/include -std=gnu99 \
-	-fsanitize=address
+	-fsanitize=address -fsanitize=undefined -fno-sanitize-recover=all -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fno-sanitize=null -fno-sanitize=alignment
 
 all: $(TARGET)
 
@@ -15,10 +15,10 @@ exe:
 	gcc $(CFLAGS) ./batchprepare.c  -o $(ROOT)batchprepare  $(LFLAGS)
 	gcc $(CFLAGS) ./stmtBatchTest.c -o $(ROOT)stmtBatchTest $(LFLAGS)
 	gcc $(CFLAGS) ./stmtTest.c -o $(ROOT)stmtTest $(LFLAGS)
-	gcc $(CFLAGS) ./stmt_function.c -o $(ROOT)stmt_function $(LFLAGS)
+	gcc $(CFLAGS) ./stmt.c -o $(ROOT)stmt $(LFLAGS)
 
 clean:
 	rm $(ROOT)batchprepare
 	rm $(ROOT)stmtBatchTest
 	rm $(ROOT)stmtTest
-	rm $(ROOT)stmt_function
+	rm $(ROOT)stmt

tests/script/api/stmt_function.c

-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "taos.h"
-#include <sys/time.h>
-#include <pthread.h>
-#include <unistd.h>
-#include <assert.h>
-
-void execute_simple_sql(void *taos, char *sql) {
-    TAOS_RES *result = taos_query(taos, sql);
-    if ( result == NULL || taos_errno(result) != 0) {
-        printf( "failed to %s, Reason: %s\n" , sql, taos_errstr(result));
-        taos_free_result(result);
-        exit(EXIT_FAILURE);
-    }
-    taos_free_result(result);
-}
-
-void print_result(TAOS_RES* res) {
-    if (res == NULL) {
-        exit(EXIT_FAILURE);
-    }
-    TAOS_ROW    row = NULL;
-    int         num_fields = taos_num_fields(res);
-    TAOS_FIELD* fields = taos_fetch_fields(res);
-    while ((row = taos_fetch_row(res))) {
-        char temp[256] = {0};
-        taos_print_row(temp, row, fields, num_fields);
-        printf("get result: %s\n", temp);
-    }
-}
-
-void taos_stmt_init_test() {
-	printf("start taos_stmt_init test \n");
-    void *taos = NULL;
-	TAOS_STMT *stmt = NULL;
-    stmt = taos_stmt_init(taos);
-	assert(stmt == NULL);
-    // ASM ERROR
-	// assert(taos_stmt_close(stmt) != 0);
-	taos = taos_connect("127.0.0.1","root","taosdata",NULL,0);
-	if(taos == NULL) {
-		printf("Cannot connect to tdengine server\n");
-		exit(EXIT_FAILURE);
-	}
-	stmt = taos_stmt_init(taos);
-	assert(stmt != NULL);
-	assert(taos_stmt_close(stmt) == 0);
-    printf("finish taos_stmt_init test\n"); 
-}
-void taos_stmt_preprare_test() {
-    printf("start taos_stmt_prepare test\n");
-    char *stmt_sql = calloc(1, 1048576);
-    TAOS_STMT *stmt = NULL;
-    assert(taos_stmt_prepare(stmt, stmt_sql, 0) != 0);
-    void *taos = NULL;	
-	taos = taos_connect("127.0.0.1","root","taosdata",NULL,0);
-	if(taos == NULL) {
-		printf("Cannot connect to tdengine server\n");
-		exit(EXIT_FAILURE);
-	}
-    execute_simple_sql(taos, "drop database if exists stmt_test");
-    execute_simple_sql(taos, "create database stmt_test");
-    execute_simple_sql(taos, "use stmt_test");
-    execute_simple_sql(taos, "create table super(ts timestamp, c1 int, c2 bigint, c3 float, c4 double, c5 binary(8), c6 smallint, c7 tinyint, c8 bool, c9 nchar(8), c10 timestamp) tags (t1 int, t2 bigint, t3 float, t4 double, t5 binary(8), t6 smallint, t7 tinyint, t8 bool, t9 nchar(8))");
-    stmt = taos_stmt_init(taos);
-    assert(stmt != NULL);
-    // below will make client dead lock
-    assert(taos_stmt_prepare(stmt, stmt_sql, 0) == 0);
-
-    // assert(taos_stmt_close(stmt) == 0);
-    // stmt = taos_stmt_init(taos);
-    assert(stmt != NULL);
-    sprintf(stmt_sql, "select from ?");
-    assert(taos_stmt_prepare(stmt, stmt_sql, 0) != 0);
-    assert(taos_stmt_close(stmt) == 0);
-
-    stmt = taos_stmt_init(taos);
-    assert(stmt != NULL);
-    sprintf(stmt_sql, "insert into ? values (?,?,?,?,?,?,?,?,?,?,?)");
-    assert(taos_stmt_prepare(stmt, stmt_sql, 0) == 0);
-    assert(taos_stmt_close(stmt) == 0);
-
-    stmt = taos_stmt_init(taos);
-    assert(stmt != NULL);
-    sprintf(stmt_sql, "insert into super values (?,?,?,?,?,?,?,?,?,?,?)");
-    assert(taos_stmt_prepare(stmt, stmt_sql, 0) != 0);
-    assert(taos_stmt_close(stmt) == 0);
-
-    stmt = taos_stmt_init(taos);
-    assert(stmt != NULL);
-    sprintf(stmt_sql, "insert into ? values (?,?,?,?,?,?,?,?,1,?,?,?)");
-    assert(taos_stmt_prepare(stmt, stmt_sql, 0) == 0);
-    assert(taos_stmt_close(stmt) == 0);
-
-    free(stmt_sql);
-    printf("finish taos_stmt_prepare test\n");
-}
-
-void taos_stmt_set_tbname_test() {
-    printf("start taos_stmt_set_tbname test\n");
-    TAOS_STMT *stmt = NULL;
-    char *name = calloc(1, 200);
-    // ASM ERROR
-    // assert(taos_stmt_set_tbname(stmt, name) != 0);
-    void *taos = taos_connect("127.0.0.1","root","taosdata",NULL,0);
-	if(taos == NULL) {
-		printf("Cannot connect to tdengine server\n");
-		exit(EXIT_FAILURE);
-	}
-    execute_simple_sql(taos, "drop database if exists stmt_test");
-    execute_simple_sql(taos, "create database stmt_test");
-    execute_simple_sql(taos, "use stmt_test");
-    execute_simple_sql(taos, "create table super(ts timestamp, c1 int)");
-    stmt = taos_stmt_init(taos);
-    assert(stmt != NULL);
-    assert(taos_stmt_set_tbname(stmt, name) != 0);
-    char* stmt_sql = calloc(1, 1000);
-    sprintf(stmt_sql, "insert into ? values (?,?)");
-    assert(taos_stmt_prepare(stmt, stmt_sql, 0) == 0);
-    sprintf(name, "super");
-    assert(stmt != NULL);
-    assert(taos_stmt_set_tbname(stmt, name) == 0);
-    free(name);
-    free(stmt_sql);
-    taos_stmt_close(stmt);
-    printf("finish taos_stmt_set_tbname test\n");
-}
-
-void taos_stmt_set_tbname_tags_test() {
-    printf("start taos_stmt_set_tbname_tags test\n");
-    TAOS_STMT *stmt = NULL;
-    char *name = calloc(1,20);
-    TAOS_BIND *tags = calloc(1, sizeof(TAOS_BIND));
-    // ASM ERROR
-    // assert(taos_stmt_set_tbname_tags(stmt, name, tags) != 0);
-    void *taos = taos_connect("127.0.0.1","root","taosdata",NULL,0);
-	if(taos == NULL) {
-		printf("Cannot connect to tdengine server\n");
-		exit(EXIT_FAILURE);
-	}
-    execute_simple_sql(taos, "drop database if exists stmt_test");
-    execute_simple_sql(taos, "create database stmt_test");
-    execute_simple_sql(taos, "use stmt_test");
-    execute_simple_sql(taos, "create stable super(ts timestamp, c1 int) tags (id int)");
-    execute_simple_sql(taos, "create table tb using super tags (1)");
-    stmt = taos_stmt_init(taos);
-    assert(stmt != NULL);
-    char* stmt_sql = calloc(1, 1000);
-    sprintf(stmt_sql, "insert into ? using super tags (?) values (?,?)");
-    assert(taos_stmt_prepare(stmt, stmt_sql, 0) == 0);
-    assert(taos_stmt_set_tbname_tags(stmt, name, tags) != 0);
-    sprintf(name, "tb");
-    assert(taos_stmt_set_tbname_tags(stmt, name, tags) != 0);
-    int t = 1;
-    tags->buffer_length = TSDB_DATA_TYPE_INT;
-    tags->buffer_length = sizeof(uint32_t);
-    tags->buffer = &t;
-    tags->length = &tags->buffer_length;
-    tags->is_null = NULL;
-    assert(taos_stmt_set_tbname_tags(stmt, name, tags) == 0);
-    free(stmt_sql);
-    free(name);
-    free(tags);
-    taos_stmt_close(stmt);
-    printf("finish taos_stmt_set_tbname_tags test\n");
-}
-
-void taos_stmt_set_sub_tbname_test() {
-    printf("start taos_stmt_set_sub_tbname test\n");
-    TAOS_STMT *stmt = NULL;
-    char *name = calloc(1, 200);
-    // ASM ERROR
-    // assert(taos_stmt_set_sub_tbname(stmt, name) != 0);
-    void *taos = taos_connect("127.0.0.1","root","taosdata",NULL,0);
-	if(taos == NULL) {
-		printf("Cannot connect to tdengine server\n");
-		exit(EXIT_FAILURE);
-	}
-    execute_simple_sql(taos, "drop database if exists stmt_test");
-    execute_simple_sql(taos, "create database stmt_test");
-    execute_simple_sql(taos, "use stmt_test");
-    execute_simple_sql(taos, "create stable super(ts timestamp, c1 int) tags (id int)");
-    execute_simple_sql(taos, "create table tb using super tags (1)");
-    stmt = taos_stmt_init(taos);
-    assert(stmt != NULL);
-    char* stmt_sql = calloc(1, 1000);
-    sprintf(stmt_sql, "insert into ? values (?,?)");
-    assert(taos_stmt_prepare(stmt, stmt_sql, 0) == 0);
-    assert(taos_stmt_set_sub_tbname(stmt, name) != 0);
-    sprintf(name, "tb");
-    assert(taos_stmt_set_sub_tbname(stmt, name) == 0);
-    // assert(taos_load_table_info(taos, "super, tb") == 0);
-    // assert(taos_stmt_set_sub_tbname(stmt, name) == 0);
-    free(name);
-    free(stmt_sql);
-    assert(taos_stmt_close(stmt) == 0);
-    printf("finish taos_stmt_set_sub_tbname test\n");
-}
-
-void taos_stmt_bind_param_test() {
-    printf("start taos_stmt_bind_param test\n");
-    TAOS_STMT *stmt = NULL;
-    TAOS_BIND *binds = NULL;
-    assert(taos_stmt_bind_param(stmt, binds) != 0);
-    void *taos = taos_connect("127.0.0.1","root","taosdata",NULL,0);
-	if(taos == NULL) {
-		printf("Cannot connect to tdengine server\n");
-		exit(EXIT_FAILURE);
-	}
-    execute_simple_sql(taos, "drop database if exists stmt_test");
-    execute_simple_sql(taos, "create database stmt_test");
-    execute_simple_sql(taos, "use stmt_test");
-    execute_simple_sql(taos, "create table super(ts timestamp, c1 int)");
-    stmt = taos_stmt_init(taos);
-    char* stmt_sql = calloc(1, 1000);
-    sprintf(stmt_sql, "insert into ? values (?,?)");
-    assert(taos_stmt_prepare(stmt, stmt_sql, 0) == 0);
-    assert(taos_stmt_bind_param(stmt, binds) != 0);
-    free(binds);
-    TAOS_BIND *params = calloc(2, sizeof(TAOS_BIND));
-    int64_t ts = (int64_t)1591060628000;
-    params[0].buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
-    params[0].buffer_length = sizeof(uint64_t);
-    params[0].buffer = &ts;
-    params[0].length = &params[0].buffer_length;
-    params[0].is_null = NULL;
-    int32_t i = (int32_t)21474;
-    params[1].buffer_type = TSDB_DATA_TYPE_INT;
-    params[1].buffer_length = sizeof(int32_t);
-    params[1].buffer = &i;
-    params[1].length = &params[1].buffer_length;
-    params[1].is_null = NULL;
-    assert(taos_stmt_bind_param(stmt, params) != 0);
-    assert(taos_stmt_set_tbname(stmt, "super") == 0);
-    assert(taos_stmt_bind_param(stmt, params) == 0);
-    free(params);
-    free(stmt_sql);
-    taos_stmt_close(stmt);
-    printf("finish taos_stmt_bind_param test\n");
-}
-
-void taos_stmt_bind_single_param_batch_test() {
-    printf("start taos_stmt_bind_single_param_batch test\n");
-    TAOS_STMT *stmt = NULL;
-    TAOS_MULTI_BIND *bind = NULL;
-    assert(taos_stmt_bind_single_param_batch(stmt, bind, 0) != 0);
-    printf("finish taos_stmt_bind_single_param_batch test\n");
-}
-
-void taos_stmt_bind_param_batch_test() {
-    printf("start taos_stmt_bind_param_batch test\n");
-    TAOS_STMT *stmt = NULL;
-    TAOS_MULTI_BIND *bind = NULL;
-    assert(taos_stmt_bind_param_batch(stmt, bind) != 0);
-    printf("finish taos_stmt_bind_param_batch test\n");
-}
-
-void taos_stmt_add_batch_test() {
-    printf("start taos_stmt_add_batch test\n");
-    TAOS_STMT *stmt = NULL;
-    assert(taos_stmt_add_batch(stmt) != 0);
-    void *taos = taos_connect("127.0.0.1","root","taosdata",NULL,0);
-	if(taos == NULL) {
-		printf("Cannot connect to tdengine server\n");
-		exit(EXIT_FAILURE);
-	}
-    execute_simple_sql(taos, "drop database if exists stmt_test");
-    execute_simple_sql(taos, "create database stmt_test");
-    execute_simple_sql(taos, "use stmt_test");
-    execute_simple_sql(taos, "create table super(ts timestamp, c1 int)");
-    stmt = taos_stmt_init(taos);
-    assert(stmt != NULL);
-    char* stmt_sql = calloc(1, 1000);
-    sprintf(stmt_sql, "insert into ? values (?,?)");
-    assert(taos_stmt_prepare(stmt, stmt_sql, 0) == 0);
-    assert(taos_stmt_add_batch(stmt) != 0);
-    TAOS_BIND *params = calloc(2, sizeof(TAOS_BIND));
-    int64_t ts = (int64_t)1591060628000;
-    params[0].buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
-    params[0].buffer_length = sizeof(uint64_t);
-    params[0].buffer = &ts;
-    params[0].length = &params[0].buffer_length;
-    params[0].is_null = NULL;
-    int32_t i = (int32_t)21474;
-    params[1].buffer_type = TSDB_DATA_TYPE_INT;
-    params[1].buffer_length = sizeof(int32_t);
-    params[1].buffer = &i;
-    params[1].length = &params[1].buffer_length;
-    params[1].is_null = NULL;
-    assert(taos_stmt_set_tbname(stmt, "super") == 0);
-    assert(taos_stmt_bind_param(stmt, params) == 0);
-    assert(taos_stmt_add_batch(stmt) == 0);
-    free(params);
-    free(stmt_sql);
-    assert(taos_stmt_close(stmt) == 0);
-    printf("finish taos_stmt_add_batch test\n");
-}
-
-void taos_stmt_execute_test() {
-    printf("start taos_stmt_execute test\n");
-    TAOS_STMT *stmt = NULL;
-    assert(taos_stmt_execute(stmt) != 0);
-    void *taos = taos_connect("127.0.0.1","root","taosdata",NULL,0);
-	if(taos == NULL) {
-		printf("Cannot connect to tdengine server\n");
-		exit(EXIT_FAILURE);
-	}
-    execute_simple_sql(taos, "drop database if exists stmt_test");
-    execute_simple_sql(taos, "create database stmt_test");
-    execute_simple_sql(taos, "use stmt_test");
-    execute_simple_sql(taos, "create table super(ts timestamp, c1 int)");
-    stmt = taos_stmt_init(taos);
-    assert(stmt != NULL);
-    assert(taos_stmt_execute(stmt) != 0);
-    char* stmt_sql = calloc(1, 1000);
-    sprintf(stmt_sql, "insert into ? values (?,?)");
-    assert(taos_stmt_prepare(stmt, stmt_sql, 0) == 0);
-    assert(taos_stmt_execute(stmt) != 0);
-    TAOS_BIND *params = calloc(2, sizeof(TAOS_BIND));
-    int64_t ts = (int64_t)1591060628000;
-    params[0].buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
-    params[0].buffer_length = sizeof(uint64_t);
-    params[0].buffer = &ts;
-    params[0].length = &params[0].buffer_length;
-    params[0].is_null = NULL;
-    int32_t i = (int32_t)21474;
-    params[1].buffer_type = TSDB_DATA_TYPE_INT;
-    params[1].buffer_length = sizeof(int32_t);
-    params[1].buffer = &i;
-    params[1].length = &params[1].buffer_length;
-    params[1].is_null = NULL;
-    assert(taos_stmt_set_tbname(stmt, "super") == 0);
-    assert(taos_stmt_execute(stmt) != 0);
-    assert(taos_stmt_bind_param(stmt, params) == 0);
-    assert(taos_stmt_execute(stmt) != 0);
-    assert(taos_stmt_add_batch(stmt) == 0);
-    assert(taos_stmt_execute(stmt) == 0);
-    free(params);
-    free(stmt_sql);
-    assert(taos_stmt_close(stmt) == 0);
-    printf("finish taos_stmt_execute test\n");
-}
-
-void taos_stmt_use_result_query(void *taos, char *col, int type) {
-    TAOS_STMT *stmt = taos_stmt_init(taos);
-    assert(stmt != NULL);
-    char *stmt_sql = calloc(1, 1024);
-    struct {
-        int64_t c1;
-        int32_t c2;
-        int64_t c3;
-        float c4;
-        double c5;
-        char c6[8];
-        int16_t c7;
-        int8_t c8;
-        int8_t c9;
-        char c10[32];
-    } v = {0};
-    v.c1 = (int64_t)1591060628000;
-    v.c2 = (int32_t)1;
-    v.c3 = (int64_t)1;
-    v.c4 = (float)1;
-    v.c5 = (double)1;
-    strcpy(v.c6, "abcdefgh");
-    v.c7 = 1;
-    v.c8 = 1;
-    v.c9 = 1;
-    strcpy(v.c10, "一二三四五六七八");
-    uintptr_t c10len=strlen(v.c10);
-    sprintf(stmt_sql, "select * from stmt_test.t1 where %s = ?", col);
-    printf("stmt_sql: %s\n", stmt_sql);
-    assert(taos_stmt_prepare(stmt, stmt_sql, 0) == 0);
-    TAOS_BIND *params = calloc(1, sizeof(TAOS_BIND));
-    params->buffer_type = type;
-    params->is_null = NULL;
-    switch(type){
-        case TSDB_DATA_TYPE_TIMESTAMP:
-            params->buffer_length = sizeof(v.c1);
-            params->buffer = &v.c1;
-            params->length = &params->buffer_length;
-            break;
-        case TSDB_DATA_TYPE_INT:
-            params->buffer_length = sizeof(v.c2);
-            params->buffer = &v.c2;
-            params->length = &params->buffer_length;
-        case TSDB_DATA_TYPE_BIGINT:
-            params->buffer_length = sizeof(v.c3);
-            params->buffer = &v.c3;
-            params->length = &params->buffer_length;
-            break;
-        case TSDB_DATA_TYPE_FLOAT:
-            params->buffer_length = sizeof(v.c4);
-            params->buffer = &v.c4;
-            params->length = &params->buffer_length;
-        case TSDB_DATA_TYPE_DOUBLE:
-            params->buffer_length = sizeof(v.c5);
-            params->buffer = &v.c5;
-            params->length = &params->buffer_length;
-            break;
-        case TSDB_DATA_TYPE_BINARY:
-            params->buffer_length = sizeof(v.c6);
-            params->buffer = &v.c6;
-            params->length = &params->buffer_length;
-            break;
-        case TSDB_DATA_TYPE_SMALLINT:
-            params->buffer_length = sizeof(v.c7);
-            params->buffer = &v.c7;
-            params->length = &params->buffer_length;
-            break;
-        case TSDB_DATA_TYPE_TINYINT:
-            params->buffer_length = sizeof(v.c8);
-            params->buffer = &v.c8;
-            params->length = &params->buffer_length;
-        case TSDB_DATA_TYPE_BOOL:
-            params->buffer_length = sizeof(v.c9);
-            params->buffer = &v.c9;
-            params->length = &params->buffer_length;
-            break;
-        case TSDB_DATA_TYPE_NCHAR:
-            params->buffer_length = sizeof(v.c10);
-            params->buffer = &v.c10;
-            params->length = &c10len;
-            break;
-        default:
-            printf("Cannnot find type: %d\n", type);
-            break;
-
-    }
-    assert(taos_stmt_bind_param(stmt, params) == 0);
-    assert(taos_stmt_execute(stmt) == 0);
-    TAOS_RES* result = taos_stmt_use_result(stmt);
-    assert(result != NULL);
-    print_result(result);
-    assert(taos_stmt_close(stmt) == 0);
-    free(params);
-    free(stmt_sql);
-    taos_free_result(result);
-}
-
-void taos_stmt_use_result_test() {
-    printf("start taos_stmt_use_result test\n");
-    void *taos = taos_connect("127.0.0.1","root","taosdata",NULL,0);
-    if(taos == NULL) {
-		printf("Cannot connect to tdengine server\n");
-		exit(EXIT_FAILURE);
-	}
-    execute_simple_sql(taos, "drop database if exists stmt_test");
-    execute_simple_sql(taos, "create database stmt_test");
-    execute_simple_sql(taos, "use stmt_test");
-    execute_simple_sql(taos, "create table super(ts timestamp, c1 int, c2 bigint, c3 float, c4 double, c5 binary(8), c6 smallint, c7 tinyint, c8 bool, c9 nchar(8), c10 timestamp) tags (t1 int, t2 bigint, t3 float, t4 double, t5 binary(8), t6 smallint, t7 tinyint, t8 bool, t9 nchar(8))");
-    execute_simple_sql(taos, "create table t1 using super tags (1, 1, 1, 1, 'abcdefgh',1,1,1,'一二三四五六七八')");
-    execute_simple_sql(taos, "insert into t1 values (1591060628000, 1, 1, 1, 1, 'abcdefgh',1,1,1,'一二三四五六七八', now)");
-    execute_simple_sql(taos, "insert into t1 values (1591060628001, 1, 1, 1, 1, 'abcdefgh',1,1,1,'一二三四五六七八', now)");
-    
-    taos_stmt_use_result_query(taos, "c1", TSDB_DATA_TYPE_INT);
-    taos_stmt_use_result_query(taos, "c2", TSDB_DATA_TYPE_BIGINT);
-    taos_stmt_use_result_query(taos, "c3", TSDB_DATA_TYPE_FLOAT);
-    taos_stmt_use_result_query(taos, "c4", TSDB_DATA_TYPE_DOUBLE);
-    taos_stmt_use_result_query(taos, "c5", TSDB_DATA_TYPE_BINARY);
-    taos_stmt_use_result_query(taos, "c6", TSDB_DATA_TYPE_SMALLINT);
-    taos_stmt_use_result_query(taos, "c7", TSDB_DATA_TYPE_TINYINT);
-    taos_stmt_use_result_query(taos, "c8", TSDB_DATA_TYPE_BOOL);
-    taos_stmt_use_result_query(taos, "c9", TSDB_DATA_TYPE_NCHAR);
-    
-    printf("finish taos_stmt_use_result test\n");
-}
-
-void taos_stmt_close_test() {
-    printf("start taos_stmt_close test\n");
-    // ASM ERROR
-    // TAOS_STMT *stmt = NULL;
-    // assert(taos_stmt_close(stmt) != 0);
-    printf("finish taos_stmt_close test\n");
-}
-
-void test_api_reliability() {
-	// ASM catch memory leak
-    taos_stmt_init_test();
-	taos_stmt_preprare_test();
-    taos_stmt_set_tbname_test();
-    taos_stmt_set_tbname_tags_test();
-    taos_stmt_set_sub_tbname_test();
-    taos_stmt_bind_param_test();
-    taos_stmt_bind_single_param_batch_test();
-    taos_stmt_bind_param_batch_test();
-    taos_stmt_add_batch_test();
-    taos_stmt_execute_test();
-    taos_stmt_close_test();
-}
-
-void test_query() {
-    taos_stmt_use_result_test();
-}
-
-int main(int argc, char *argv[]) {
-    test_api_reliability();
-    test_query();
-    return 0;
-}
\ No newline at end of file

tests/test-all.sh

@@ -497,7 +497,7 @@ if [ "$2" != "sim" ] && [ "$2" != "python" ] && [ "$2" != "jdbc" ] && [ "$2" !=
     totalExamplePass=`expr $totalExamplePass + 1`
   fi 
 
-  ./prepare 127.0.0.1 > /dev/null 2>&1
+  ./prepare > /dev/null 2>&1
   if [ $? != "0" ]; then
     echo "prepare failed"
     totalExampleFailed=`expr $totalExampleFailed + 1`