C/C++ Connector

C/C++ 开发人员可以使用 TDengine 的客户端驱动，即 C/C++连接器 （以下都用 TDengine 客户端驱动表示），开发自己的应用来连接 TDengine 集群完成数据存储、查询以及其他功能。TDengine 客户端驱动的 API 类似于 MySQL 的 C API。应用程序使用时，需要包含 TDengine 头文件 taos.h，里面列出了提供的 API 的函数原型；应用程序还要链接到所在平台上对应的动态库。

  1. #include <taos.h>

TDengine 服务端或客户端安装后，taos.h 位于：

  • Linux：/usr/local/taos/include
  • Windows：C:\TDengine\include

TDengine 客户端驱动的动态库位于：

  • Linux: /usr/local/taos/driver/libtaos.so
  • Windows: C:\TDengine\taos.dll

支持的平台

请参考支持的平台列表

支持的版本

TDengine 客户端驱动的版本号与 TDengine 服务端的版本号是一一对应的强对应关系，建议使用与 TDengine 服务端完全相同的客户端驱动。虽然低版本的客户端驱动在前三段版本号一致（即仅第四段版本号不同）的情况下也能够与高版本的服务端相兼容，但这并非推荐用法。强烈不建议使用高版本的客户端驱动访问低版本的服务端。

安装步骤

TDengine 客户端驱动的安装请参考 安装指南

建立连接

使用客户端驱动访问 TDengine 集群的基本过程为：建立连接、查询和写入、关闭连接、清除资源。

下面为建立连接的示例代码，其中省略了查询和写入部分，展示了如何建立连接、关闭连接以及清除资源。

  1.   TAOS *taos = taos_connect("localhost:6030", "root", "taosdata", NULL, 0);
  2.   if (taos == NULL) {
  3.     printf("failed to connect to server, reason:%s\n", "null taos" /*taos_errstr(taos)*/);
  4.     exit(1);
  5.   }
  7.   /* put your code here for read and write */
  9.   taos_close(taos);
  10.   taos_cleanup();

在上面的示例代码中， taos_connect() 建立到客户端程序所在主机的 6030 端口的连接，taos_close()关闭当前连接，taos_cleanup()清除客户端驱动所申请和使用的资源。

C/C++ - 图1note
  • 如未特别说明，当 API 的返回值是整数时，0 代表成功，其它是代表失败原因的错误码，当返回值是指针时， NULL 表示失败。
  • 所有的错误码以及对应的原因描述在 taoserror.h 文件中。

示例程序

本节展示了使用客户端驱动访问 TDengine 集群的常见访问方式的示例代码。

同步查询示例

同步查询

  1. /*
  2.  * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
  3.  *
  4.  * This program is free software: you can use, redistribute, and/or modify
  5.  * it under the terms of the GNU Affero General Public License, version 3
  6.  * or later ("AGPL"), as published by the Free Software Foundation.
  7.  *
  8.  * This program is distributed in the hope that it will be useful, but WITHOUT
  9.  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10.  * FITNESS FOR A PARTICULAR PURPOSE.
  11.  *
  12.  * You should have received a copy of the GNU Affero General Public License
  13.  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  14.  */
  16. // TAOS standard API example. The same syntax as MySQL, but only a subset
  17. // to compile: gcc -o demo demo.c -ltaos
  19. #include <inttypes.h>
  20. #include <stdio.h>
  21. #include <stdlib.h>
  22. #include <string.h>
  23. #include <taos.h>  // TAOS header file
  25. static void queryDB(TAOS *taos, char *command) {
  26.   int       i;
  27.   TAOS_RES *pSql = NULL;
  28.   int32_t   code = -1;
  30.   for (i = 0; i < 5; i++) {
  31.     if (NULL != pSql) {
  32.       taos_free_result(pSql);
  33.       pSql = NULL;
  34.     }
  36.     pSql = taos_query(taos, command);
  37.     code = taos_errno(pSql);
  38.     if (0 == code) {
  39.       break;
  40.     }
  41.   }
  43.   if (code != 0) {
  44.     fprintf(stderr, "Failed to run %s, reason: %s\n", command, taos_errstr(pSql));
  45.     taos_free_result(pSql);
  46.     taos_close(taos);
  47.     exit(EXIT_FAILURE);
  48.   }
  50.   taos_free_result(pSql);
  51. }
  53. void Test(TAOS *taos, char *qstr, int i);
  55. int main(int argc, char *argv[]) {
  56.   char qstr[1024];
  58.   // connect to server
  59.   if (argc < 2) {
  60.     printf("please input server-ip \n");
  61.     return 0;
  62.   }
  64.   TAOS *taos = taos_connect(argv[1], "root", "taosdata", NULL, 0);
  65.   if (taos == NULL) {
  66.     printf("failed to connect to server, reason:%s\n", "null taos" /*taos_errstr(taos)*/);
  67.     exit(1);
  68.   }
  69.   for (int i = 0; i < 100; i++) {
  70.     Test(taos, qstr, i);
  71.   }
  72.   taos_close(taos);
  73.   taos_cleanup();
  74. }
  75. void Test(TAOS *taos, char *qstr, int index) {
  76.   printf("==================test at %d\n================================", index);
  77.   queryDB(taos, "drop database if exists demo");
  78.   queryDB(taos, "create database demo");
  79.   TAOS_RES *result;
  80.   queryDB(taos, "use demo");
  82.   queryDB(taos,
  83.           "create table m1 (ts timestamp, ti tinyint, si smallint, i int, bi bigint, f float, d double, b binary(10))");
  84.   printf("success to create table\n");
  86.   int i = 0;
  87.   for (i = 0; i < 10; ++i) {
  88.     sprintf(qstr, "insert into m1 values (%" PRId64 ", %d, %d, %d, %d, %f, %lf, '%s')",
  89.             (uint64_t)(1546300800000 + i * 1000), i, i, i, i * 10000000, i * 1.0, i * 2.0, "hello");
  90.     printf("qstr: %s\n", qstr);
  92.     // note: how do you wanna do if taos_query returns non-NULL
  93.     // if (taos_query(taos, qstr)) {
  94.     //   printf("insert row: %i, reason:%s\n", i, taos_errstr(taos));
  95.     // }
  96.     TAOS_RES *result1 = taos_query(taos, qstr);
  97.     if (result1 == NULL || taos_errno(result1) != 0) {
  98.       printf("failed to insert row, reason:%s\n", taos_errstr(result1));
  99.       taos_free_result(result1);
  100.       exit(1);
  101.     } else {
  102.       printf("insert row: %i\n", i);
  103.     }
  104.     taos_free_result(result1);
  105.   }
  106.   printf("success to insert rows, total %d rows\n", i);
  108.   // query the records
  109.   sprintf(qstr, "SELECT * FROM m1");
  110.   result = taos_query(taos, qstr);
  111.   if (result == NULL || taos_errno(result) != 0) {
  112.     printf("failed to select, reason:%s\n", taos_errstr(result));
  113.     taos_free_result(result);
  114.     exit(1);
  115.   }
  117.   TAOS_ROW    row;
  118.   int         rows = 0;
  119.   int         num_fields = taos_field_count(result);
  120.   TAOS_FIELD *fields = taos_fetch_fields(result);
  122.   printf("num_fields = %d\n", num_fields);
  123.   printf("select * from table, result:\n");
  124.   // fetch the records row by row
  125.   while ((row = taos_fetch_row(result))) {
  126.     char temp[1024] = {0};
  127.     rows++;
  128.     taos_print_row(temp, row, fields, num_fields);
  129.     printf("%s\n", temp);
  130.   }
  132.   taos_free_result(result);
  133.   printf("====demo end====\n\n");
  134. }

查看源码

异步查询示例

异步查询

  1. /*
  2.  * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
  3.  *
  4.  * This program is free software: you can use, redistribute, and/or modify
  5.  * it under the terms of the GNU Affero General Public License, version 3
  6.  * or later ("AGPL"), as published by the Free Software Foundation.
  7.  *
  8.  * This program is distributed in the hope that it will be useful, but WITHOUT
  9.  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10.  * FITNESS FOR A PARTICULAR PURPOSE.
  11.  *
  12.  * You should have received a copy of the GNU Affero General Public License
  13.  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  14.  */
  16. // TAOS asynchronous API example
  17. // this example opens multiple tables, insert/retrieve multiple tables
  18. // it is used by TAOS internally for one performance testing
  19. // to compiple: gcc -o asyncdemo asyncdemo.c -ltaos
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #include <string.h>
  24. #include <sys/time.h>
  25. #include <unistd.h>
  27. #include <taos.h>
  29. int     points = 5;
  30. int     numOfTables = 3;
  31. int     tablesInsertProcessed = 0;
  32. int     tablesSelectProcessed = 0;
  33. int64_t st, et;
  35. typedef struct {
  36.   int    id;
  37.   TAOS * taos;
  38.   char   name[16];
  39.   time_t timeStamp;
  40.   int    value;
  41.   int    rowsInserted;
  42.   int    rowsTried;
  43.   int    rowsRetrieved;
  44. } STable;
  46. void taos_insert_call_back(void *param, TAOS_RES *tres, int code);
  47. void taos_select_call_back(void *param, TAOS_RES *tres, int code);
  48. void taos_error(TAOS *taos);
  50. static void queryDB(TAOS *taos, char *command) {
  51.   int       i;
  52.   TAOS_RES *pSql = NULL;
  53.   int32_t   code = -1;
  55.   for (i = 0; i < 5; i++) {
  56.     if (NULL != pSql) {
  57.       taos_free_result(pSql);
  58.       pSql = NULL;
  59.     }
  61.     pSql = taos_query(taos, command);
  62.     code = taos_errno(pSql);
  63.     if (0 == code) {
  64.       break;
  65.     }
  66.   }
  68.   if (code != 0) {
  69.     fprintf(stderr, "Failed to run %s, reason: %s\n", command, taos_errstr(pSql));
  70.     taos_free_result(pSql);
  71.     taos_close(taos);
  72.     taos_cleanup();
  73.     exit(EXIT_FAILURE);
  74.   }
  76.   taos_free_result(pSql);
  77. }
  79. int main(int argc, char *argv[]) {
  80.   TAOS *         taos;
  81.   struct timeval systemTime;
  82.   int            i;
  83.   char           sql[1024] = {0};
  84.   char           prefix[20] = {0};
  85.   char           db[128] = {0};
  86.   STable *       tableList;
  88.   if (argc != 5) {
  89.     printf("usage: %s server-ip dbname rowsPerTable numOfTables\n", argv[0]);
  90.     exit(0);
  91.   }
  93.   // a simple way to parse input parameters
  94.   if (argc >= 3) strcpy(db, argv[2]);
  95.   if (argc >= 4) points = atoi(argv[3]);
  96.   if (argc >= 5) numOfTables = atoi(argv[4]);
  98.   size_t size = sizeof(STable) * (size_t)numOfTables;
  99.   tableList = (STable *)malloc(size);
  100.   memset(tableList, 0, size);
  102.   taos = taos_connect(argv[1], "root", "taosdata", NULL, 0);
  103.   if (taos == NULL) taos_error(taos);
  105.   printf("success to connect to server\n");
  107.   sprintf(sql, "drop database if exists %s", db);
  108.   queryDB(taos, sql);
  110.   sprintf(sql, "create database %s", db);
  111.   queryDB(taos, sql);
  113.   sprintf(sql, "use %s", db);
  114.   queryDB(taos, sql);
  116.   strcpy(prefix, "asytbl_");
  117.   for (i = 0; i < numOfTables; ++i) {
  118.     tableList[i].id = i;
  119.     tableList[i].taos = taos;
  120.     sprintf(tableList[i].name, "%s%d", prefix, i);
  121.     sprintf(sql, "create table %s%d (ts timestamp, volume bigint)", prefix, i);
  122.     queryDB(taos, sql);
  123.   }
  125.   gettimeofday(&systemTime, NULL);
  126.   for (i = 0; i < numOfTables; ++i)
  127.     tableList[i].timeStamp = (time_t)(systemTime.tv_sec) * 1000 + systemTime.tv_usec / 1000;
  129.   printf("success to create tables, press any key to insert\n");
  130.   getchar();
  132.   printf("start to insert...\n");
  133.   gettimeofday(&systemTime, NULL);
  134.   st = systemTime.tv_sec * 1000000 + systemTime.tv_usec;
  136.   tablesInsertProcessed = 0;
  137.   tablesSelectProcessed = 0;
  139.   for (i = 0; i < numOfTables; ++i) {
  140.     // insert records in asynchronous API
  141.     sprintf(sql, "insert into %s values(%ld, 0)", tableList[i].name, 1546300800000 + i);
  142.     taos_query_a(taos, sql, taos_insert_call_back, (void *)(tableList + i));
  143.   }
  145.   printf("once insert finished, presse any key to query\n");
  146.   getchar();
  148.   while (1) {
  149.     if (tablesInsertProcessed < numOfTables) {
  150.       printf("wait for process finished\n");
  151.       sleep(1);
  152.       continue;
  153.     }
  155.     break;
  156.   }
  158.   printf("start to query...\n");
  159.   gettimeofday(&systemTime, NULL);
  160.   st = systemTime.tv_sec * 1000000 + systemTime.tv_usec;
  162.   for (i = 0; i < numOfTables; ++i) {
  163.     // select records in asynchronous API
  164.     sprintf(sql, "select * from %s", tableList[i].name);
  165.     taos_query_a(taos, sql, taos_select_call_back, (void *)(tableList + i));
  166.   }
  168.   printf("\nonce finished, press any key to exit\n");
  169.   getchar();
  171.   while (1) {
  172.     if (tablesSelectProcessed < numOfTables) {
  173.       printf("wait for process finished\n");
  174.       sleep(1);
  175.       continue;
  176.     }
  178.     break;
  179.   }
  181.   for (i = 0; i < numOfTables; ++i) {
  182.     printf("%s inserted:%d retrieved:%d\n", tableList[i].name, tableList[i].rowsInserted, tableList[i].rowsRetrieved);
  183.   }
  185.   taos_close(taos);
  186.   free(tableList);
  188.   printf("==== async demo end====\n");
  189.   printf("\n");
  190.   return 0;
  191. }
  193. void taos_error(TAOS *con) {
  194.   fprintf(stderr, "TDengine error: %s\n", taos_errstr(con));
  195.   taos_close(con);
  196.   taos_cleanup();
  197.   exit(1);
  198. }
  200. void taos_insert_call_back(void *param, TAOS_RES *tres, int code) {
  201.   STable *       pTable = (STable *)param;
  202.   struct timeval systemTime;
  203.   char           sql[128];
  205.   pTable->rowsTried++;
  207.   if (code < 0) {
  208.     printf("%s insert failed, code:%d, rows:%d\n", pTable->name, code, pTable->rowsTried);
  209.   } else if (code == 0) {
  210.     printf("%s not inserted\n", pTable->name);
  211.   } else {
  212.     pTable->rowsInserted++;
  213.   }
  215.   if (pTable->rowsTried < points) {
  216.     // for this demo, insert another record
  217.     sprintf(sql, "insert into %s values(%ld, %d)", pTable->name, 1546300800000 + pTable->rowsTried * 1000,
  218.             pTable->rowsTried);
  219.     taos_query_a(pTable->taos, sql, taos_insert_call_back, (void *)pTable);
  220.   } else {
  221.     printf("%d rows data are inserted into %s\n", points, pTable->name);
  222.     tablesInsertProcessed++;
  223.     if (tablesInsertProcessed >= numOfTables) {
  224.       gettimeofday(&systemTime, NULL);
  225.       et = systemTime.tv_sec * 1000000 + systemTime.tv_usec;
  226.       printf("%lld mseconds to insert %d data points\n", (et - st) / 1000, points * numOfTables);
  227.     }
  228.   }
  230.   taos_free_result(tres);
  231. }
  233. void taos_retrieve_call_back(void *param, TAOS_RES *tres, int numOfRows) {
  234.   STable *       pTable = (STable *)param;
  235.   struct timeval systemTime;
  237.   if (numOfRows > 0) {
  238.     for (int i = 0; i < numOfRows; ++i) {
  239.       // synchronous API to retrieve a row from batch of records
  240.       /*TAOS_ROW row = */ (void)taos_fetch_row(tres);
  241.       // process row
  242.     }
  244.     pTable->rowsRetrieved += numOfRows;
  246.     // retrieve next batch of rows
  247.     taos_fetch_rows_a(tres, taos_retrieve_call_back, pTable);
  249.   } else {
  250.     if (numOfRows < 0) printf("%s retrieve failed, code:%d\n", pTable->name, numOfRows);
  252.     // taos_free_result(tres);
  253.     printf("%d rows data retrieved from %s\n", pTable->rowsRetrieved, pTable->name);
  255.     tablesSelectProcessed++;
  256.     if (tablesSelectProcessed >= numOfTables) {
  257.       gettimeofday(&systemTime, NULL);
  258.       et = systemTime.tv_sec * 1000000 + systemTime.tv_usec;
  259.       printf("%lld mseconds to query %d data rows\n", (et - st) / 1000, points * numOfTables);
  260.     }
  262.     taos_free_result(tres);
  263.   }
  264. }
  266. void taos_select_call_back(void *param, TAOS_RES *tres, int code) {
  267.   STable *pTable = (STable *)param;
  269.   if (code == 0 && tres) {
  270.     // asynchronous API to fetch a batch of records
  271.     taos_fetch_rows_a(tres, taos_retrieve_call_back, pTable);
  272.   } else {
  273.     printf("%s select failed, code:%d\n", pTable->name, code);
  274.     taos_free_result(tres);
  275.     taos_cleanup();
  276.     exit(1);
  277.   }
  278. }

查看源码

参数绑定示例

参数绑定

  1. // TAOS standard API example. The same syntax as MySQL, but only a subet
  2. // to compile: gcc -o prepare prepare.c -ltaos
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <string.h>
  7. #include <taos.h>
  8. #include <unistd.h>
  10. void taosMsleep(int mseconds);
  12. void verify_prepare(TAOS* taos) {
  13.   TAOS_RES* result = taos_query(taos, "drop database if exists test;");
  14.   taos_free_result(result);
  16.   usleep(100000);
  17.   result = taos_query(taos, "create database test;");
  19.   int code = taos_errno(result);
  20.   if (code != 0) {
  21.     printf("\033[31mfailed to create database, reason:%s\033[0m\n", taos_errstr(result));
  22.     taos_free_result(result);
  23.     exit(EXIT_FAILURE);
  24.   }
  26.   taos_free_result(result);
  28.   usleep(100000);
  29.   taos_select_db(taos, "test");
  31.   // create table
  32.   const char* sql =
  33.       "create table m1 (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, bin "
  34.       "binary(40), blob nchar(10), u1 tinyint unsigned, u2 smallint unsigned, u4 int unsigned, u8 bigint unsigned)";
  35.   result = taos_query(taos, sql);
  36.   code = taos_errno(result);
  37.   if (code != 0) {
  38.     printf("\033[31mfailed to create table, reason:%s\033[0m\n", taos_errstr(result));
  39.     taos_free_result(result);
  40.     exit(EXIT_FAILURE);
  41.   }
  42.   taos_free_result(result);
  44.   // insert 10 records
  45.   struct {
  46.     int64_t  ts;
  47.     int8_t   b;
  48.     int8_t   v1;
  49.     int16_t  v2;
  50.     int32_t  v4;
  51.     int64_t  v8;
  52.     float    f4;
  53.     double   f8;
  54.     char     bin[40];
  55.     char     blob[80];
  56.     uint8_t  u1;
  57.     uint16_t u2;
  58.     uint32_t u4;
  59.     uint64_t u8;
  60.   } v = {0};
  62.   TAOS_STMT* stmt = taos_stmt_init(taos);
  63.   TAOS_BIND  params[14];
  64.   params[0].buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
  65.   params[0].buffer_length = sizeof(v.ts);
  66.   params[0].buffer = &v.ts;
  67.   params[0].length = &params[0].buffer_length;
  68.   params[0].is_null = NULL;
  70.   params[1].buffer_type = TSDB_DATA_TYPE_BOOL;
  71.   params[1].buffer_length = sizeof(v.b);
  72.   params[1].buffer = &v.b;
  73.   params[1].length = &params[1].buffer_length;
  74.   params[1].is_null = NULL;
  76.   params[2].buffer_type = TSDB_DATA_TYPE_TINYINT;
  77.   params[2].buffer_length = sizeof(v.v1);
  78.   params[2].buffer = &v.v1;
  79.   params[2].length = &params[2].buffer_length;
  80.   params[2].is_null = NULL;
  82.   params[3].buffer_type = TSDB_DATA_TYPE_SMALLINT;
  83.   params[3].buffer_length = sizeof(v.v2);
  84.   params[3].buffer = &v.v2;
  85.   params[3].length = &params[3].buffer_length;
  86.   params[3].is_null = NULL;
  88.   params[4].buffer_type = TSDB_DATA_TYPE_INT;
  89.   params[4].buffer_length = sizeof(v.v4);
  90.   params[4].buffer = &v.v4;
  91.   params[4].length = &params[4].buffer_length;
  92.   params[4].is_null = NULL;
  94.   params[5].buffer_type = TSDB_DATA_TYPE_BIGINT;
  95.   params[5].buffer_length = sizeof(v.v8);
  96.   params[5].buffer = &v.v8;
  97.   params[5].length = &params[5].buffer_length;
  98.   params[5].is_null = NULL;
  100.   params[6].buffer_type = TSDB_DATA_TYPE_FLOAT;
  101.   params[6].buffer_length = sizeof(v.f4);
  102.   params[6].buffer = &v.f4;
  103.   params[6].length = &params[6].buffer_length;
  104.   params[6].is_null = NULL;
  106.   params[7].buffer_type = TSDB_DATA_TYPE_DOUBLE;
  107.   params[7].buffer_length = sizeof(v.f8);
  108.   params[7].buffer = &v.f8;
  109.   params[7].length = &params[7].buffer_length;
  110.   params[7].is_null = NULL;
  112.   params[8].buffer_type = TSDB_DATA_TYPE_BINARY;
  113.   params[8].buffer_length = sizeof(v.bin);
  114.   params[8].buffer = v.bin;
  115.   params[8].length = &params[8].buffer_length;
  116.   params[8].is_null = NULL;
  118.   strcpy(v.blob, "一二三四五六七八九十");
  119.   params[9].buffer_type = TSDB_DATA_TYPE_NCHAR;
  120.   params[9].buffer_length = strlen(v.blob);
  121.   params[9].buffer = v.blob;
  122.   params[9].length = &params[9].buffer_length;
  123.   params[9].is_null = NULL;
  125.   params[10].buffer_type = TSDB_DATA_TYPE_UTINYINT;
  126.   params[10].buffer_length = sizeof(v.u1);
  127.   params[10].buffer = &v.u1;
  128.   params[10].length = &params[10].buffer_length;
  129.   params[10].is_null = NULL;
  131.   params[11].buffer_type = TSDB_DATA_TYPE_USMALLINT;
  132.   params[11].buffer_length = sizeof(v.u2);
  133.   params[11].buffer = &v.u2;
  134.   params[11].length = &params[11].buffer_length;
  135.   params[11].is_null = NULL;
  137.   params[12].buffer_type = TSDB_DATA_TYPE_UINT;
  138.   params[12].buffer_length = sizeof(v.u4);
  139.   params[12].buffer = &v.u4;
  140.   params[12].length = &params[12].buffer_length;
  141.   params[12].is_null = NULL;
  143.   params[13].buffer_type = TSDB_DATA_TYPE_UBIGINT;
  144.   params[13].buffer_length = sizeof(v.u8);
  145.   params[13].buffer = &v.u8;
  146.   params[13].length = &params[13].buffer_length;
  147.   params[13].is_null = NULL;
  149.   int is_null = 1;
  151.   sql = "insert into m1 values(?,?,?,?,?,?,?,?,?,?,?,?,?,?)";
  152.   code = taos_stmt_prepare(stmt, sql, 0);
  153.   if (code != 0) {
  154.     printf("\033[31mfailed to execute taos_stmt_prepare. error:%s\033[0m\n", taos_stmt_errstr(stmt));
  155.     taos_stmt_close(stmt);
  156.     exit(EXIT_FAILURE);
  157.   }
  158.   v.ts = 1591060628000;
  159.   for (int i = 0; i < 10; ++i) {
  160.     v.ts += 1;
  161.     for (int j = 1; j < 10; ++j) {
  162.       params[j].is_null = ((i == j) ? &is_null : 0);
  163.     }
  164.     v.b = (int8_t)i % 2;
  165.     v.v1 = (int8_t)i;
  166.     v.v2 = (int16_t)(i * 2);
  167.     v.v4 = (int32_t)(i * 4);
  168.     v.v8 = (int64_t)(i * 8);
  169.     v.f4 = (float)(i * 40);
  170.     v.f8 = (double)(i * 80);
  171.     for (int j = 0; j < sizeof(v.bin); ++j) {
  172.       v.bin[j] = (char)(i + '0');
  173.     }
  174.     v.u1 = (uint8_t)i;
  175.     v.u2 = (uint16_t)(i * 2);
  176.     v.u4 = (uint32_t)(i * 4);
  177.     v.u8 = (uint64_t)(i * 8);
  179.     taos_stmt_bind_param(stmt, params);
  180.     taos_stmt_add_batch(stmt);
  181.   }
  182.   if (taos_stmt_execute(stmt) != 0) {
  183.     printf("\033[31mfailed to execute insert statement.error:%s\033[0m\n", taos_stmt_errstr(stmt));
  184.     taos_stmt_close(stmt);
  185.     exit(EXIT_FAILURE);
  186.   }
  188.   int affectedRows = taos_stmt_affected_rows(stmt);
  189.   printf("sucessfully inserted %d rows\n", affectedRows);
  191.   taos_stmt_close(stmt);
  193.   // query the records
  194.   stmt = taos_stmt_init(taos);
  195.   taos_stmt_prepare(stmt, "SELECT * FROM m1 WHERE v1 > ? AND v2 < ?", 0);
  196.   v.v1 = 5;
  197.   v.v2 = 15;
  198.   taos_stmt_bind_param(stmt, params + 2);
  199.   if (taos_stmt_execute(stmt) != 0) {
  200.     printf("\033[31mfailed to execute select statement.error:%s\033[0m\n", taos_stmt_errstr(stmt));
  201.     taos_stmt_close(stmt);
  202.     exit(EXIT_FAILURE);
  203.   }
  205.   result = taos_stmt_use_result(stmt);
  207.   TAOS_ROW    row;
  208.   int         rows = 0;
  209.   int         num_fields = taos_num_fields(result);
  210.   TAOS_FIELD* fields = taos_fetch_fields(result);
  212.   // fetch the records row by row
  213.   while ((row = taos_fetch_row(result))) {
  214.     char temp[256] = {0};
  215.     rows++;
  216.     taos_print_row(temp, row, fields, num_fields);
  217.     printf("%s\n", temp);
  218.   }
  220.   taos_free_result(result);
  221.   taos_stmt_close(stmt);
  222. }
  224. void verify_prepare2(TAOS* taos) {
  225.   TAOS_RES* result = taos_query(taos, "drop database if exists test;");
  226.   taos_free_result(result);
  227.   usleep(100000);
  228.   result = taos_query(taos, "create database test;");
  230.   int code = taos_errno(result);
  231.   if (code != 0) {
  232.     printf("\033[31mfailed to create database, reason:%s\033[0m\n", taos_errstr(result));
  233.     taos_free_result(result);
  234.     exit(EXIT_FAILURE);
  235.   }
  236.   taos_free_result(result);
  238.   usleep(100000);
  239.   taos_select_db(taos, "test");
  241.   // create table
  242.   const char* sql =
  243.       "create table m1 (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, bin "
  244.       "binary(40), blob nchar(10), u1 tinyint unsigned, u2 smallint unsigned, u4 int unsigned, u8 bigint unsigned)";
  245.   result = taos_query(taos, sql);
  246.   code = taos_errno(result);
  247.   if (code != 0) {
  248.     printf("\033[31mfailed to create table, reason:%s\033[0m\n", taos_errstr(result));
  249.     taos_free_result(result);
  250.     exit(EXIT_FAILURE);
  251.   }
  252.   taos_free_result(result);
  254.   // insert 10 records
  255.   struct {
  256.     int64_t  ts;
  257.     int8_t   b;
  258.     int8_t   v1;
  259.     int16_t  v2;
  260.     int32_t  v4;
  261.     int64_t  v8;
  262.     float    f4;
  263.     double   f8;
  264.     char     bin[40];
  265.     char     blob[80];
  266.     uint8_t  u1;
  267.     uint16_t u2;
  268.     uint32_t u4;
  269.     uint64_t u8;
  270.   } v = {0};
  272.   TAOS_STMT* stmt = taos_stmt_init(taos);
  273.   TAOS_BIND  params[14];
  274.   params[0].buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
  275.   params[0].buffer_length = sizeof(v.ts);
  276.   params[0].buffer = &v.ts;
  277.   params[0].length = &params[0].buffer_length;
  278.   params[0].is_null = NULL;
  280.   params[1].buffer_type = TSDB_DATA_TYPE_BOOL;
  281.   params[1].buffer_length = sizeof(v.b);
  282.   params[1].buffer = &v.b;
  283.   params[1].length = &params[1].buffer_length;
  284.   params[1].is_null = NULL;
  286.   params[2].buffer_type = TSDB_DATA_TYPE_TINYINT;
  287.   params[2].buffer_length = sizeof(v.v1);
  288.   params[2].buffer = &v.v1;
  289.   params[2].length = &params[2].buffer_length;
  290.   params[2].is_null = NULL;
  292.   params[3].buffer_type = TSDB_DATA_TYPE_SMALLINT;
  293.   params[3].buffer_length = sizeof(v.v2);
  294.   params[3].buffer = &v.v2;
  295.   params[3].length = &params[3].buffer_length;
  296.   params[3].is_null = NULL;
  298.   params[4].buffer_type = TSDB_DATA_TYPE_INT;
  299.   params[4].buffer_length = sizeof(v.v4);
  300.   params[4].buffer = &v.v4;
  301.   params[4].length = &params[4].buffer_length;
  302.   params[4].is_null = NULL;
  304.   params[5].buffer_type = TSDB_DATA_TYPE_BIGINT;
  305.   params[5].buffer_length = sizeof(v.v8);
  306.   params[5].buffer = &v.v8;
  307.   params[5].length = &params[5].buffer_length;
  308.   params[5].is_null = NULL;
  310.   params[6].buffer_type = TSDB_DATA_TYPE_FLOAT;
  311.   params[6].buffer_length = sizeof(v.f4);
  312.   params[6].buffer = &v.f4;
  313.   params[6].length = &params[6].buffer_length;
  314.   params[6].is_null = NULL;
  316.   params[7].buffer_type = TSDB_DATA_TYPE_DOUBLE;
  317.   params[7].buffer_length = sizeof(v.f8);
  318.   params[7].buffer = &v.f8;
  319.   params[7].length = &params[7].buffer_length;
  320.   params[7].is_null = NULL;
  322.   params[8].buffer_type = TSDB_DATA_TYPE_BINARY;
  323.   params[8].buffer_length = sizeof(v.bin);
  324.   params[8].buffer = v.bin;
  325.   params[8].length = &params[8].buffer_length;
  326.   params[8].is_null = NULL;
  328.   strcpy(v.blob, "一二三四五六七八九十");
  329.   params[9].buffer_type = TSDB_DATA_TYPE_NCHAR;
  330.   params[9].buffer_length = strlen(v.blob);
  331.   params[9].buffer = v.blob;
  332.   params[9].length = &params[9].buffer_length;
  333.   params[9].is_null = NULL;
  335.   params[10].buffer_type = TSDB_DATA_TYPE_UTINYINT;
  336.   params[10].buffer_length = sizeof(v.u1);
  337.   params[10].buffer = &v.u1;
  338.   params[10].length = &params[10].buffer_length;
  339.   params[10].is_null = NULL;
  341.   params[11].buffer_type = TSDB_DATA_TYPE_USMALLINT;
  342.   params[11].buffer_length = sizeof(v.u2);
  343.   params[11].buffer = &v.u2;
  344.   params[11].length = &params[11].buffer_length;
  345.   params[11].is_null = NULL;
  347.   params[12].buffer_type = TSDB_DATA_TYPE_UINT;
  348.   params[12].buffer_length = sizeof(v.u4);
  349.   params[12].buffer = &v.u4;
  350.   params[12].length = &params[12].buffer_length;
  351.   params[12].is_null = NULL;
  353.   params[13].buffer_type = TSDB_DATA_TYPE_UBIGINT;
  354.   params[13].buffer_length = sizeof(v.u8);
  355.   params[13].buffer = &v.u8;
  356.   params[13].length = &params[13].buffer_length;
  357.   params[13].is_null = NULL;
  359.   sql = "insert into ? values(?,?,?,?,?,?,?,?,?,?,?,?,?,?)";
  360.   code = taos_stmt_prepare(stmt, sql, 0);
  361.   if (code != 0) {
  362.     printf("\033[31mfailed to execute taos_stmt_prepare. error:%s\033[0m\n", taos_stmt_errstr(stmt));
  363.     taos_stmt_close(stmt);
  364.     exit(EXIT_FAILURE);
  365.   }
  367.   code = taos_stmt_set_tbname(stmt, "m1");
  368.   if (code != 0) {
  369.     printf("\033[31mfailed to execute taos_stmt_prepare. error:%s\033[0m\n", taos_stmt_errstr(stmt));
  370.     taos_stmt_close(stmt);
  371.     exit(EXIT_FAILURE);
  372.   }
  374.   int is_null = 1;
  376.   v.ts = 1591060628000;
  377.   for (int i = 0; i < 10; ++i) {
  378.     v.ts += 1;
  379.     for (int j = 1; j < 10; ++j) {
  380.       params[j].is_null = ((i == j) ? &is_null : 0);
  381.     }
  382.     v.b = (int8_t)i % 2;
  383.     v.v1 = (int8_t)i;
  384.     v.v2 = (int16_t)(i * 2);
  385.     v.v4 = (int32_t)(i * 4);
  386.     v.v8 = (int64_t)(i * 8);
  387.     v.f4 = (float)(i * 40);
  388.     v.f8 = (double)(i * 80);
  389.     for (int j = 0; j < sizeof(v.bin); ++j) {
  390.       v.bin[j] = (char)(i + '0');
  391.     }
  392.     v.u1 = (uint8_t)i;
  393.     v.u2 = (uint16_t)(i * 2);
  394.     v.u4 = (uint32_t)(i * 4);
  395.     v.u8 = (uint64_t)(i * 8);
  397.     taos_stmt_bind_param(stmt, params);
  398.     taos_stmt_add_batch(stmt);
  399.   }
  401.   if (taos_stmt_execute(stmt) != 0) {
  402.     printf("\033[31mfailed to execute insert statement.error:%s\033[0m\n", taos_stmt_errstr(stmt));
  403.     taos_stmt_close(stmt);
  404.     exit(EXIT_FAILURE);
  405.   }
  407.   int affectedRows = taos_stmt_affected_rows(stmt);
  408.   printf("sucessfully inserted %d rows\n", affectedRows);
  410.   taos_stmt_close(stmt);
  412.   // query the records
  413.   stmt = taos_stmt_init(taos);
  414.   taos_stmt_prepare(stmt, "SELECT * FROM m1 WHERE v1 > ? AND v2 < ?", 0);
  415.   TAOS_BIND qparams[2];
  417.   int8_t  v1 = 5;
  418.   int16_t v2 = 15;
  419.   qparams[0].buffer_type = TSDB_DATA_TYPE_TINYINT;
  420.   qparams[0].buffer_length = sizeof(v1);
  421.   qparams[0].buffer = &v1;
  422.   qparams[0].length = &qparams[0].buffer_length;
  423.   qparams[0].is_null = NULL;
  425.   qparams[1].buffer_type = TSDB_DATA_TYPE_SMALLINT;
  426.   qparams[1].buffer_length = sizeof(v2);
  427.   qparams[1].buffer = &v2;
  428.   qparams[1].length = &qparams[1].buffer_length;
  429.   qparams[1].is_null = NULL;
  431.   taos_stmt_bind_param(stmt, qparams);
  432.   if (taos_stmt_execute(stmt) != 0) {
  433.     printf("\033[31mfailed to execute select statement.error:%s\033[0m\n", taos_stmt_errstr(stmt));
  434.     taos_stmt_close(stmt);
  435.     exit(EXIT_FAILURE);
  436.   }
  438.   result = taos_stmt_use_result(stmt);
  440.   TAOS_ROW    row;
  441.   int         rows = 0;
  442.   int         num_fields = taos_num_fields(result);
  443.   TAOS_FIELD* fields = taos_fetch_fields(result);
  445.   // fetch the records row by row
  446.   while ((row = taos_fetch_row(result))) {
  447.     char temp[256] = {0};
  448.     rows++;
  449.     taos_print_row(temp, row, fields, num_fields);
  450.     printf("%s\n", temp);
  451.   }
  453.   taos_free_result(result);
  454.   taos_stmt_close(stmt);
  455. }
  457. void verify_prepare3(TAOS* taos) {
  458.   TAOS_RES* result = taos_query(taos, "drop database if exists test;");
  459.   taos_free_result(result);
  460.   usleep(100000);
  461.   result = taos_query(taos, "create database test;");
  463.   int code = taos_errno(result);
  464.   if (code != 0) {
  465.     printf("\033[31mfailed to create database, reason:%s\033[0m\n", taos_errstr(result));
  466.     taos_free_result(result);
  467.     exit(EXIT_FAILURE);
  468.   }
  469.   taos_free_result(result);
  471.   usleep(100000);
  472.   taos_select_db(taos, "test");
  474.   // create table
  475.   const char* sql =
  476.       "create stable st1 (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, bin "
  477.       "binary(40), blob nchar(10), u1 tinyint unsigned, u2 smallint unsigned, u4 int unsigned, u8 bigint unsigned) "
  478.       "tags "
  479.       "(b_tag bool, v1_tag tinyint, v2_tag smallint, v4_tag int, v8_tag bigint, f4_tag float, f8_tag double, bin_tag "
  480.       "binary(40), blob_tag nchar(10), u1_tag tinyint unsigned, u2_tag smallint unsigned, u4_tag int unsigned, u8_tag "
  481.       "bigint "
  482.       "unsigned)";
  483.   result = taos_query(taos, sql);
  484.   code = taos_errno(result);
  485.   if (code != 0) {
  486.     printf("\033[31mfailed to create table, reason:%s\033[0m\n", taos_errstr(result));
  487.     taos_free_result(result);
  488.     exit(EXIT_FAILURE);
  489.   }
  490.   taos_free_result(result);
  492.   TAOS_BIND tags[13];
  494.   struct {
  495.     int8_t   b;
  496.     int8_t   v1;
  497.     int16_t  v2;
  498.     int32_t  v4;
  499.     int64_t  v8;
  500.     float    f4;
  501.     double   f8;
  502.     char     bin[40];
  503.     char     blob[80];
  504.     uint8_t  u1;
  505.     uint16_t u2;
  506.     uint32_t u4;
  507.     uint64_t u8;
  508.   } id = {0};
  510.   id.b = (int8_t)1;
  511.   id.v1 = (int8_t)1;
  512.   id.v2 = (int16_t)2;
  513.   id.v4 = (int32_t)4;
  514.   id.v8 = (int64_t)8;
  515.   id.f4 = (float)40;
  516.   id.f8 = (double)80;
  517.   for (int j = 0; j < sizeof(id.bin); ++j) {
  518.     id.bin[j] = (char)('1' + '0');
  519.   }
  520.   strcpy(id.blob, "一二三四五六七八九十");
  521.   id.u1 = (uint8_t)1;
  522.   id.u2 = (uint16_t)2;
  523.   id.u4 = (uint32_t)4;
  524.   id.u8 = (uint64_t)8;
  526.   tags[0].buffer_type = TSDB_DATA_TYPE_BOOL;
  527.   tags[0].buffer_length = sizeof(id.b);
  528.   tags[0].buffer = &id.b;
  529.   tags[0].length = &tags[0].buffer_length;
  530.   tags[0].is_null = NULL;
  532.   tags[1].buffer_type = TSDB_DATA_TYPE_TINYINT;
  533.   tags[1].buffer_length = sizeof(id.v1);
  534.   tags[1].buffer = &id.v1;
  535.   tags[1].length = &tags[1].buffer_length;
  536.   tags[1].is_null = NULL;
  538.   tags[2].buffer_type = TSDB_DATA_TYPE_SMALLINT;
  539.   tags[2].buffer_length = sizeof(id.v2);
  540.   tags[2].buffer = &id.v2;
  541.   tags[2].length = &tags[2].buffer_length;
  542.   tags[2].is_null = NULL;
  544.   tags[3].buffer_type = TSDB_DATA_TYPE_INT;
  545.   tags[3].buffer_length = sizeof(id.v4);
  546.   tags[3].buffer = &id.v4;
  547.   tags[3].length = &tags[3].buffer_length;
  548.   tags[3].is_null = NULL;
  550.   tags[4].buffer_type = TSDB_DATA_TYPE_BIGINT;
  551.   tags[4].buffer_length = sizeof(id.v8);
  552.   tags[4].buffer = &id.v8;
  553.   tags[4].length = &tags[4].buffer_length;
  554.   tags[4].is_null = NULL;
  556.   tags[5].buffer_type = TSDB_DATA_TYPE_FLOAT;
  557.   tags[5].buffer_length = sizeof(id.f4);
  558.   tags[5].buffer = &id.f4;
  559.   tags[5].length = &tags[5].buffer_length;
  560.   tags[5].is_null = NULL;
  562.   tags[6].buffer_type = TSDB_DATA_TYPE_DOUBLE;
  563.   tags[6].buffer_length = sizeof(id.f8);
  564.   tags[6].buffer = &id.f8;
  565.   tags[6].length = &tags[6].buffer_length;
  566.   tags[6].is_null = NULL;
  568.   tags[7].buffer_type = TSDB_DATA_TYPE_BINARY;
  569.   tags[7].buffer_length = sizeof(id.bin);
  570.   tags[7].buffer = &id.bin;
  571.   tags[7].length = &tags[7].buffer_length;
  572.   tags[7].is_null = NULL;
  574.   tags[8].buffer_type = TSDB_DATA_TYPE_NCHAR;
  575.   tags[8].buffer_length = strlen(id.blob);
  576.   tags[8].buffer = &id.blob;
  577.   tags[8].length = &tags[8].buffer_length;
  578.   tags[8].is_null = NULL;
  580.   tags[9].buffer_type = TSDB_DATA_TYPE_UTINYINT;
  581.   tags[9].buffer_length = sizeof(id.u1);
  582.   tags[9].buffer = &id.u1;
  583.   tags[9].length = &tags[9].buffer_length;
  584.   tags[9].is_null = NULL;
  586.   tags[10].buffer_type = TSDB_DATA_TYPE_USMALLINT;
  587.   tags[10].buffer_length = sizeof(id.u2);
  588.   tags[10].buffer = &id.u2;
  589.   tags[10].length = &tags[10].buffer_length;
  590.   tags[10].is_null = NULL;
  592.   tags[11].buffer_type = TSDB_DATA_TYPE_UINT;
  593.   tags[11].buffer_length = sizeof(id.u4);
  594.   tags[11].buffer = &id.u4;
  595.   tags[11].length = &tags[11].buffer_length;
  596.   tags[11].is_null = NULL;
  598.   tags[12].buffer_type = TSDB_DATA_TYPE_UBIGINT;
  599.   tags[12].buffer_length = sizeof(id.u8);
  600.   tags[12].buffer = &id.u8;
  601.   tags[12].length = &tags[12].buffer_length;
  602.   tags[12].is_null = NULL;
  603.   // insert 10 records
  604.   struct {
  605.     int64_t  ts[10];
  606.     int8_t   b[10];
  607.     int8_t   v1[10];
  608.     int16_t  v2[10];
  609.     int32_t  v4[10];
  610.     int64_t  v8[10];
  611.     float    f4[10];
  612.     double   f8[10];
  613.     char     bin[10][40];
  614.     char     blob[10][80];
  615.     uint8_t  u1[10];
  616.     uint16_t u2[10];
  617.     uint32_t u4[10];
  618.     uint64_t u8[10];
  619.   } v;
  621.   int32_t* t8_len = malloc(sizeof(int32_t) * 10);
  622.   int32_t* t16_len = malloc(sizeof(int32_t) * 10);
  623.   int32_t* t32_len = malloc(sizeof(int32_t) * 10);
  624.   int32_t* t64_len = malloc(sizeof(int32_t) * 10);
  625.   int32_t* float_len = malloc(sizeof(int32_t) * 10);
  626.   int32_t* double_len = malloc(sizeof(int32_t) * 10);
  627.   int32_t* bin_len = malloc(sizeof(int32_t) * 10);
  628.   int32_t* blob_len = malloc(sizeof(int32_t) * 10);
  629.   int32_t* u8_len = malloc(sizeof(int32_t) * 10);
  630.   int32_t* u16_len = malloc(sizeof(int32_t) * 10);
  631.   int32_t* u32_len = malloc(sizeof(int32_t) * 10);
  632.   int32_t* u64_len = malloc(sizeof(int32_t) * 10);
  634.   TAOS_STMT*      stmt = taos_stmt_init(taos);
  635.   TAOS_MULTI_BIND params[14];
  636.   char            is_null[10] = {0};
  638.   params[0].buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
  639.   params[0].buffer_length = sizeof(v.ts[0]);
  640.   params[0].buffer = v.ts;
  641.   params[0].length = t64_len;
  642.   params[0].is_null = is_null;
  643.   params[0].num = 10;
  645.   params[1].buffer_type = TSDB_DATA_TYPE_BOOL;
  646.   params[1].buffer_length = sizeof(v.b[0]);
  647.   params[1].buffer = v.b;
  648.   params[1].length = t8_len;
  649.   params[1].is_null = is_null;
  650.   params[1].num = 10;
  652.   params[2].buffer_type = TSDB_DATA_TYPE_TINYINT;
  653.   params[2].buffer_length = sizeof(v.v1[0]);
  654.   params[2].buffer = v.v1;
  655.   params[2].length = t8_len;
  656.   params[2].is_null = is_null;
  657.   params[2].num = 10;
  659.   params[3].buffer_type = TSDB_DATA_TYPE_SMALLINT;
  660.   params[3].buffer_length = sizeof(v.v2[0]);
  661.   params[3].buffer = v.v2;
  662.   params[3].length = t16_len;
  663.   params[3].is_null = is_null;
  664.   params[3].num = 10;
  666.   params[4].buffer_type = TSDB_DATA_TYPE_INT;
  667.   params[4].buffer_length = sizeof(v.v4[0]);
  668.   params[4].buffer = v.v4;
  669.   params[4].length = t32_len;
  670.   params[4].is_null = is_null;
  671.   params[4].num = 10;
  673.   params[5].buffer_type = TSDB_DATA_TYPE_BIGINT;
  674.   params[5].buffer_length = sizeof(v.v8[0]);
  675.   params[5].buffer = v.v8;
  676.   params[5].length = t64_len;
  677.   params[5].is_null = is_null;
  678.   params[5].num = 10;
  680.   params[6].buffer_type = TSDB_DATA_TYPE_FLOAT;
  681.   params[6].buffer_length = sizeof(v.f4[0]);
  682.   params[6].buffer = v.f4;
  683.   params[6].length = float_len;
  684.   params[6].is_null = is_null;
  685.   params[6].num = 10;
  687.   params[7].buffer_type = TSDB_DATA_TYPE_DOUBLE;
  688.   params[7].buffer_length = sizeof(v.f8[0]);
  689.   params[7].buffer = v.f8;
  690.   params[7].length = double_len;
  691.   params[7].is_null = is_null;
  692.   params[7].num = 10;
  694.   params[8].buffer_type = TSDB_DATA_TYPE_BINARY;
  695.   params[8].buffer_length = sizeof(v.bin[0]);
  696.   params[8].buffer = v.bin;
  697.   params[8].length = bin_len;
  698.   params[8].is_null = is_null;
  699.   params[8].num = 10;
  701.   params[9].buffer_type = TSDB_DATA_TYPE_NCHAR;
  702.   params[9].buffer_length = sizeof(v.blob[0]);
  703.   params[9].buffer = v.blob;
  704.   params[9].length = blob_len;
  705.   params[9].is_null = is_null;
  706.   params[9].num = 10;
  708.   params[10].buffer_type = TSDB_DATA_TYPE_UTINYINT;
  709.   params[10].buffer_length = sizeof(v.u1[0]);
  710.   params[10].buffer = v.u1;
  711.   params[10].length = u8_len;
  712.   params[10].is_null = is_null;
  713.   params[10].num = 10;
  715.   params[11].buffer_type = TSDB_DATA_TYPE_USMALLINT;
  716.   params[11].buffer_length = sizeof(v.u2[0]);
  717.   params[11].buffer = v.u2;
  718.   params[11].length = u16_len;
  719.   params[11].is_null = is_null;
  720.   params[11].num = 10;
  722.   params[12].buffer_type = TSDB_DATA_TYPE_UINT;
  723.   params[12].buffer_length = sizeof(v.u4[0]);
  724.   params[12].buffer = v.u4;
  725.   params[12].length = u32_len;
  726.   params[12].is_null = is_null;
  727.   params[12].num = 10;
  729.   params[13].buffer_type = TSDB_DATA_TYPE_UBIGINT;
  730.   params[13].buffer_length = sizeof(v.u8[0]);
  731.   params[13].buffer = v.u8;
  732.   params[13].length = u64_len;
  733.   params[13].is_null = is_null;
  734.   params[13].num = 10;
  736.   sql = "insert into ? using st1 tags(?,?,?,?,?,?,?,?,?,?,?,?,?) values(?,?,?,?,?,?,?,?,?,?,?,?,?,?)";
  737.   code = taos_stmt_prepare(stmt, sql, 0);
  738.   if (code != 0) {
  739.     printf("\033[31mfailed to execute taos_stmt_prepare. error:%s\033[0m\n", taos_stmt_errstr(stmt));
  740.     taos_stmt_close(stmt);
  741.     exit(EXIT_FAILURE);
  742.   }
  744.   code = taos_stmt_set_tbname_tags(stmt, "m1", tags);
  745.   if (code != 0) {
  746.     printf("\033[31mfailed to execute taos_stmt_set_tbname_tags. error:%s\033[0m\n", taos_stmt_errstr(stmt));
  747.     taos_stmt_close(stmt);
  748.     exit(EXIT_FAILURE);
  749.   }
  751.   int64_t ts = 1591060628000;
  752.   for (int i = 0; i < 10; ++i) {
  753.     v.ts[i] = ts++;
  754.     is_null[i] = 0;
  756.     v.b[i] = (int8_t)i % 2;
  757.     v.v1[i] = (int8_t)i;
  758.     v.v2[i] = (int16_t)(i * 2);
  759.     v.v4[i] = (int32_t)(i * 4);
  760.     v.v8[i] = (int64_t)(i * 8);
  761.     v.f4[i] = (float)(i * 40);
  762.     v.f8[i] = (double)(i * 80);
  763.     for (int j = 0; j < sizeof(v.bin[0]); ++j) {
  764.       v.bin[i][j] = (char)(i + '0');
  765.     }
  766.     strcpy(v.blob[i], "一二三四五六七八九十");
  767.     v.u1[i] = (uint8_t)i;
  768.     v.u2[i] = (uint16_t)(i * 2);
  769.     v.u4[i] = (uint32_t)(i * 4);
  770.     v.u8[i] = (uint64_t)(i * 8);
  772.     t8_len[i] = sizeof(int8_t);
  773.     t16_len[i] = sizeof(int16_t);
  774.     t32_len[i] = sizeof(int32_t);
  775.     t64_len[i] = sizeof(int64_t);
  776.     float_len[i] = sizeof(float);
  777.     double_len[i] = sizeof(double);
  778.     bin_len[i] = sizeof(v.bin[0]);
  779.     blob_len[i] = (int32_t)strlen(v.blob[i]);
  780.     u8_len[i] = sizeof(uint8_t);
  781.     u16_len[i] = sizeof(uint16_t);
  782.     u32_len[i] = sizeof(uint32_t);
  783.     u64_len[i] = sizeof(uint64_t);
  784.   }
  786.   taos_stmt_bind_param_batch(stmt, params);
  787.   taos_stmt_add_batch(stmt);
  789.   if (taos_stmt_execute(stmt) != 0) {
  790.     printf("\033[31mfailed to execute insert statement.error:%s\033[0m\n", taos_stmt_errstr(stmt));
  791.     taos_stmt_close(stmt);
  792.     exit(EXIT_FAILURE);
  793.   }
  795.   int affectedRows = taos_stmt_affected_rows(stmt);
  796.   printf("successfully inserted %d rows\n", affectedRows);
  798.   taos_stmt_close(stmt);
  800.   // query the records
  801.   stmt = taos_stmt_init(taos);
  802.   taos_stmt_prepare(stmt, "SELECT * FROM m1 WHERE v1 > ? AND v2 < ?", 0);
  804.   TAOS_BIND qparams[2];
  806.   int8_t  v1 = 5;
  807.   int16_t v2 = 15;
  808.   qparams[0].buffer_type = TSDB_DATA_TYPE_TINYINT;
  809.   qparams[0].buffer_length = sizeof(v1);
  810.   qparams[0].buffer = &v1;
  811.   qparams[0].length = &qparams[0].buffer_length;
  812.   qparams[0].is_null = NULL;
  814.   qparams[1].buffer_type = TSDB_DATA_TYPE_SMALLINT;
  815.   qparams[1].buffer_length = sizeof(v2);
  816.   qparams[1].buffer = &v2;
  817.   qparams[1].length = &qparams[1].buffer_length;
  818.   qparams[1].is_null = NULL;
  820.   taos_stmt_bind_param(stmt, qparams);
  821.   if (taos_stmt_execute(stmt) != 0) {
  822.     printf("\033[31mfailed to execute select statement.error:%s\033[0m\n", taos_stmt_errstr(stmt));
  823.     taos_stmt_close(stmt);
  824.     exit(EXIT_FAILURE);
  825.   }
  827.   result = taos_stmt_use_result(stmt);
  829.   TAOS_ROW    row;
  830.   int         rows = 0;
  831.   int         num_fields = taos_num_fields(result);
  832.   TAOS_FIELD* fields = taos_fetch_fields(result);
  834.   // fetch the records row by row
  835.   while ((row = taos_fetch_row(result))) {
  836.     char temp[256] = {0};
  837.     rows++;
  838.     taos_print_row(temp, row, fields, num_fields);
  839.     printf("%s\n", temp);
  840.   }
  842.   taos_free_result(result);
  843.   taos_stmt_close(stmt);
  845.   free(t8_len);
  846.   free(t16_len);
  847.   free(t32_len);
  848.   free(t64_len);
  849.   free(float_len);
  850.   free(double_len);
  851.   free(bin_len);
  852.   free(blob_len);
  853.   free(u8_len);
  854.   free(u16_len);
  855.   free(u32_len);
  856.   free(u64_len);
  858. }
  860. /**
  861.  * @brief Verify the upper/lower case of tableName for create(by setTableName)/query/show/describe/drop.
  862.  *  https://jira.taosdata.com:18080/browse/TS-904
  863.  *  https://jira.taosdata.com:18090/pages/viewpage.action?pageId=129140555
  864.  * @param taos
  865.  */
  866. void verify_prepare4(TAOS* taos) {
  867.   printf("Verify the upper/lower case of tableName for create(by setTableName)/query/show/describe/drop etc.\n");
  869.   TAOS_RES* result = taos_query(taos, "drop database if exists test;");
  870.   taos_free_result(result);
  871.   usleep(100000);
  872.   result = taos_query(taos, "create database test;");
  874.   int code = taos_errno(result);
  875.   if (code != 0) {
  876.     printf("\033[31mfailed to create database, reason:%s\033[0m\n", taos_errstr(result));
  877.     taos_free_result(result);
  878.     exit(EXIT_FAILURE);
  879.   }
  880.   taos_free_result(result);
  882.   usleep(100000);
  883.   taos_select_db(taos, "test");
  885.   // create table
  886.   const char* sql =
  887.       "create stable st1 (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, bin "
  888.       "binary(40), blob nchar(10), u1 tinyint unsigned, u2 smallint unsigned, u4 int unsigned, u8 bigint unsigned) "
  889.       "tags "
  890.       "(b_tag bool, v1_tag tinyint, v2_tag smallint, v4_tag int, v8_tag bigint, f4_tag float, f8_tag double, bin_tag "
  891.       "binary(40), blob_tag nchar(10), u1_tag tinyint unsigned, u2_tag smallint unsigned, u4_tag int unsigned, u8_tag "
  892.       "bigint "
  893.       "unsigned)";
  894.   result = taos_query(taos, sql);
  895.   code = taos_errno(result);
  896.   if (code != 0) {
  897.     printf("\033[31mfailed to create table, reason:%s\033[0m\n", taos_errstr(result));
  898.     taos_free_result(result);
  899.     exit(EXIT_FAILURE);
  900.   }
  901.   taos_free_result(result);
  903.   TAOS_BIND tags[13];
  905.   struct {
  906.     int8_t   b;
  907.     int8_t   v1;
  908.     int16_t  v2;
  909.     int32_t  v4;
  910.     int64_t  v8;
  911.     float    f4;
  912.     double   f8;
  913.     char     bin[40];
  914.     char     blob[80];
  915.     uint8_t  u1;
  916.     uint16_t u2;
  917.     uint32_t u4;
  918.     uint64_t u8;
  919.   } id = {0};
  921.   id.b = (int8_t)1;
  922.   id.v1 = (int8_t)1;
  923.   id.v2 = (int16_t)2;
  924.   id.v4 = (int32_t)4;
  925.   id.v8 = (int64_t)8;
  926.   id.f4 = (float)40;
  927.   id.f8 = (double)80;
  928.   for (int j = 0; j < sizeof(id.bin); ++j) {
  929.     id.bin[j] = (char)('1' + '0');
  930.   }
  931.   strcpy(id.blob, "一二三四五六七八九十");
  932.   id.u1 = (uint8_t)1;
  933.   id.u2 = (uint16_t)2;
  934.   id.u4 = (uint32_t)4;
  935.   id.u8 = (uint64_t)8;
  937.   tags[0].buffer_type = TSDB_DATA_TYPE_BOOL;
  938.   tags[0].buffer_length = sizeof(id.b);
  939.   tags[0].buffer = &id.b;
  940.   tags[0].length = &tags[0].buffer_length;
  941.   tags[0].is_null = NULL;
  943.   tags[1].buffer_type = TSDB_DATA_TYPE_TINYINT;
  944.   tags[1].buffer_length = sizeof(id.v1);
  945.   tags[1].buffer = &id.v1;
  946.   tags[1].length = &tags[1].buffer_length;
  947.   tags[1].is_null = NULL;
  949.   tags[2].buffer_type = TSDB_DATA_TYPE_SMALLINT;
  950.   tags[2].buffer_length = sizeof(id.v2);
  951.   tags[2].buffer = &id.v2;
  952.   tags[2].length = &tags[2].buffer_length;
  953.   tags[2].is_null = NULL;
  955.   tags[3].buffer_type = TSDB_DATA_TYPE_INT;
  956.   tags[3].buffer_length = sizeof(id.v4);
  957.   tags[3].buffer = &id.v4;
  958.   tags[3].length = &tags[3].buffer_length;
  959.   tags[3].is_null = NULL;
  961.   tags[4].buffer_type = TSDB_DATA_TYPE_BIGINT;
  962.   tags[4].buffer_length = sizeof(id.v8);
  963.   tags[4].buffer = &id.v8;
  964.   tags[4].length = &tags[4].buffer_length;
  965.   tags[4].is_null = NULL;
  967.   tags[5].buffer_type = TSDB_DATA_TYPE_FLOAT;
  968.   tags[5].buffer_length = sizeof(id.f4);
  969.   tags[5].buffer = &id.f4;
  970.   tags[5].length = &tags[5].buffer_length;
  971.   tags[5].is_null = NULL;
  973.   tags[6].buffer_type = TSDB_DATA_TYPE_DOUBLE;
  974.   tags[6].buffer_length = sizeof(id.f8);
  975.   tags[6].buffer = &id.f8;
  976.   tags[6].length = &tags[6].buffer_length;
  977.   tags[6].is_null = NULL;
  979.   tags[7].buffer_type = TSDB_DATA_TYPE_BINARY;
  980.   tags[7].buffer_length = sizeof(id.bin);
  981.   tags[7].buffer = &id.bin;
  982.   tags[7].length = &tags[7].buffer_length;
  983.   tags[7].is_null = NULL;
  985.   tags[8].buffer_type = TSDB_DATA_TYPE_NCHAR;
  986.   tags[8].buffer_length = strlen(id.blob);
  987.   tags[8].buffer = &id.blob;
  988.   tags[8].length = &tags[8].buffer_length;
  989.   tags[8].is_null = NULL;
  991.   tags[9].buffer_type = TSDB_DATA_TYPE_UTINYINT;
  992.   tags[9].buffer_length = sizeof(id.u1);
  993.   tags[9].buffer = &id.u1;
  994.   tags[9].length = &tags[9].buffer_length;
  995.   tags[9].is_null = NULL;
  997.   tags[10].buffer_type = TSDB_DATA_TYPE_USMALLINT;
  998.   tags[10].buffer_length = sizeof(id.u2);
  999.   tags[10].buffer = &id.u2;
  1000.   tags[10].length = &tags[10].buffer_length;
  1001.   tags[10].is_null = NULL;
  1003.   tags[11].buffer_type = TSDB_DATA_TYPE_UINT;
  1004.   tags[11].buffer_length = sizeof(id.u4);
  1005.   tags[11].buffer = &id.u4;
  1006.   tags[11].length = &tags[11].buffer_length;
  1007.   tags[11].is_null = NULL;
  1009.   tags[12].buffer_type = TSDB_DATA_TYPE_UBIGINT;
  1010.   tags[12].buffer_length = sizeof(id.u8);
  1011.   tags[12].buffer = &id.u8;
  1012.   tags[12].length = &tags[12].buffer_length;
  1013.   tags[12].is_null = NULL;
  1014.   // insert 10 records
  1015.   struct {
  1016.     int64_t  ts[10];
  1017.     int8_t   b[10];
  1018.     int8_t   v1[10];
  1019.     int16_t  v2[10];
  1020.     int32_t  v4[10];
  1021.     int64_t  v8[10];
  1022.     float    f4[10];
  1023.     double   f8[10];
  1024.     char     bin[10][40];
  1025.     char     blob[10][80];
  1026.     uint8_t  u1[10];
  1027.     uint16_t u2[10];
  1028.     uint32_t u4[10];
  1029.     uint64_t u8[10];
  1030.   } v;
  1032.   int32_t* t8_len = malloc(sizeof(int32_t) * 10);
  1033.   int32_t* t16_len = malloc(sizeof(int32_t) * 10);
  1034.   int32_t* t32_len = malloc(sizeof(int32_t) * 10);
  1035.   int32_t* t64_len = malloc(sizeof(int32_t) * 10);
  1036.   int32_t* float_len = malloc(sizeof(int32_t) * 10);
  1037.   int32_t* double_len = malloc(sizeof(int32_t) * 10);
  1038.   int32_t* bin_len = malloc(sizeof(int32_t) * 10);
  1039.   int32_t* blob_len = malloc(sizeof(int32_t) * 10);
  1040.   int32_t* u8_len = malloc(sizeof(int32_t) * 10);
  1041.   int32_t* u16_len = malloc(sizeof(int32_t) * 10);
  1042.   int32_t* u32_len = malloc(sizeof(int32_t) * 10);
  1043.   int32_t* u64_len = malloc(sizeof(int32_t) * 10);
  1045.   TAOS_MULTI_BIND params[14];
  1046.   char            is_null[10] = {0};
  1047.   params[0].buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
  1048.   params[0].buffer_length = sizeof(v.ts[0]);
  1049.   params[0].buffer = v.ts;
  1050.   params[0].length = t64_len;
  1051.   params[0].is_null = is_null;
  1052.   params[0].num = 10;
  1054.   params[1].buffer_type = TSDB_DATA_TYPE_BOOL;
  1055.   params[1].buffer_length = sizeof(v.b[0]);
  1056.   params[1].buffer = v.b;
  1057.   params[1].length = t8_len;
  1058.   params[1].is_null = is_null;
  1059.   params[1].num = 10;
  1061.   params[2].buffer_type = TSDB_DATA_TYPE_TINYINT;
  1062.   params[2].buffer_length = sizeof(v.v1[0]);
  1063.   params[2].buffer = v.v1;
  1064.   params[2].length = t8_len;
  1065.   params[2].is_null = is_null;
  1066.   params[2].num = 10;
  1068.   params[3].buffer_type = TSDB_DATA_TYPE_SMALLINT;
  1069.   params[3].buffer_length = sizeof(v.v2[0]);
  1070.   params[3].buffer = v.v2;
  1071.   params[3].length = t16_len;
  1072.   params[3].is_null = is_null;
  1073.   params[3].num = 10;
  1075.   params[4].buffer_type = TSDB_DATA_TYPE_INT;
  1076.   params[4].buffer_length = sizeof(v.v4[0]);
  1077.   params[4].buffer = v.v4;
  1078.   params[4].length = t32_len;
  1079.   params[4].is_null = is_null;
  1080.   params[4].num = 10;
  1082.   params[5].buffer_type = TSDB_DATA_TYPE_BIGINT;
  1083.   params[5].buffer_length = sizeof(v.v8[0]);
  1084.   params[5].buffer = v.v8;
  1085.   params[5].length = t64_len;
  1086.   params[5].is_null = is_null;
  1087.   params[5].num = 10;
  1089.   params[6].buffer_type = TSDB_DATA_TYPE_FLOAT;
  1090.   params[6].buffer_length = sizeof(v.f4[0]);
  1091.   params[6].buffer = v.f4;
  1092.   params[6].length = float_len;
  1093.   params[6].is_null = is_null;
  1094.   params[6].num = 10;
  1096.   params[7].buffer_type = TSDB_DATA_TYPE_DOUBLE;
  1097.   params[7].buffer_length = sizeof(v.f8[0]);
  1098.   params[7].buffer = v.f8;
  1099.   params[7].length = double_len;
  1100.   params[7].is_null = is_null;
  1101.   params[7].num = 10;
  1103.   params[8].buffer_type = TSDB_DATA_TYPE_BINARY;
  1104.   params[8].buffer_length = sizeof(v.bin[0]);
  1105.   params[8].buffer = v.bin;
  1106.   params[8].length = bin_len;
  1107.   params[8].is_null = is_null;
  1108.   params[8].num = 10;
  1110.   params[9].buffer_type = TSDB_DATA_TYPE_NCHAR;
  1111.   params[9].buffer_length = sizeof(v.blob[0]);
  1112.   params[9].buffer = v.blob;
  1113.   params[9].length = blob_len;
  1114.   params[9].is_null = is_null;
  1115.   params[9].num = 10;
  1117.   params[10].buffer_type = TSDB_DATA_TYPE_UTINYINT;
  1118.   params[10].buffer_length = sizeof(v.u1[0]);
  1119.   params[10].buffer = v.u1;
  1120.   params[10].length = u8_len;
  1121.   params[10].is_null = is_null;
  1122.   params[10].num = 10;
  1124.   params[11].buffer_type = TSDB_DATA_TYPE_USMALLINT;
  1125.   params[11].buffer_length = sizeof(v.u2[0]);
  1126.   params[11].buffer = v.u2;
  1127.   params[11].length = u16_len;
  1128.   params[11].is_null = is_null;
  1129.   params[11].num = 10;
  1131.   params[12].buffer_type = TSDB_DATA_TYPE_UINT;
  1132.   params[12].buffer_length = sizeof(v.u4[0]);
  1133.   params[12].buffer = v.u4;
  1134.   params[12].length = u32_len;
  1135.   params[12].is_null = is_null;
  1136.   params[12].num = 10;
  1138.   params[13].buffer_type = TSDB_DATA_TYPE_UBIGINT;
  1139.   params[13].buffer_length = sizeof(v.u8[0]);
  1140.   params[13].buffer = v.u8;
  1141.   params[13].length = u64_len;
  1142.   params[13].is_null = is_null;
  1143.   params[13].num = 10;
  1145. // verify table names for upper/lower case
  1146. #define VERIFY_CNT 5
  1148.   typedef struct {
  1149.     char setTbName[20];
  1150.     char showName[20];
  1151.     char describeName[20];
  1152.     char queryName[20];
  1153.     char dropName[20];
  1154.   } STbNames;
  1156.   /**
  1157.    * @brief
  1158.    *  0       - success expected
  1159.    *  NonZero - fail expected
  1160.    */
  1161.   typedef struct {
  1162.     int32_t setTbName;
  1163.     int32_t showName;
  1164.     int32_t describeName;
  1165.     int32_t queryName;
  1166.     int32_t dropName;
  1167.   } STbNamesResult;
  1169.   STbNames       tbName[VERIFY_CNT] = {0};
  1170.   STbNamesResult tbNameResult[VERIFY_CNT] = {0};
  1172.   STbNames*       pTbName = NULL;
  1173.   STbNamesResult* pTbNameResult = NULL;
  1175.   pTbName = &tbName[0];
  1176.   pTbNameResult = &tbNameResult[0];
  1177.   strcpy(pTbName->setTbName, "Mn1");
  1178.   strcpy(pTbName->showName, "mn1");
  1179.   strcpy(pTbName->describeName, "mn1");
  1180.   strcpy(pTbName->queryName, "mn1");
  1181.   strcpy(pTbName->dropName, "mn1");
  1183.   pTbName = &tbName[1];
  1184.   pTbNameResult = &tbNameResult[1];
  1185.   strcpy(pTbName->setTbName, "'Mn1'");
  1186.   strcpy(pTbName->showName, "'mn1'");
  1187.   strcpy(pTbName->describeName, "'mn1'");
  1188.   strcpy(pTbName->queryName, "'mn1'");
  1189.   strcpy(pTbName->dropName, "'mn1'");
  1191.   pTbName = &tbName[2];
  1192.   pTbNameResult = &tbNameResult[2];
  1193.   strcpy(pTbName->setTbName, "\"Mn1\"");
  1194.   strcpy(pTbName->showName, "\"mn1\"");
  1195.   strcpy(pTbName->describeName, "\"mn1\"");
  1196.   strcpy(pTbName->queryName, "\"mn1\"");
  1197.   strcpy(pTbName->dropName, "\"mn1\"");
  1199.   pTbName = &tbName[3];
  1200.   pTbNameResult = &tbNameResult[3];
  1201.   strcpy(pTbName->setTbName, "\"Mn1\"");
  1202.   strcpy(pTbName->showName, "'mn1'");
  1203.   strcpy(pTbName->describeName, "'mn1'");
  1204.   strcpy(pTbName->queryName, "mn1");
  1205.   strcpy(pTbName->dropName, "\"mn1\"");
  1207.   pTbName = &tbName[4];
  1208.   pTbNameResult = &tbNameResult[4];
  1209.   strcpy(pTbName->setTbName, "`Mn1`");
  1210.   strcpy(pTbName->showName, "Mn1");  // TODO support uniform of ``
  1211.   strcpy(pTbName->describeName, "`Mn1`");
  1212.   strcpy(pTbName->queryName, "`Mn1`");
  1213.   strcpy(pTbName->dropName, "`Mn1`");
  1215.   TAOS_STMT* stmt = NULL;
  1217.   for (int n = 0; n < VERIFY_CNT; ++n) {
  1218.     printf("\033[31m[%d] ===================================\033[0m\n", n);
  1219.     pTbName = &tbName[n];
  1220.     pTbNameResult = &tbNameResult[n];
  1221.     char tmpStr[256] = {0};
  1223.     // set table name
  1224.     stmt = taos_stmt_init(taos);
  1225.     if (!stmt) {
  1226.       printf("\033[31m[%d] failed to execute taos_stmt_init. error:%s\033[0m\n", n);
  1227.       exit(EXIT_FAILURE);
  1228.     }
  1230.     sql = "insert into ? using st1 tags(?,?,?,?,?,?,?,?,?,?,?,?,?) values(?,?,?,?,?,?,?,?,?,?,?,?,?,?)";
  1231.     code = taos_stmt_prepare(stmt, sql, 0);
  1232.     if (code != 0) {
  1233.       printf("\033[31mfailed to execute taos_stmt_prepare. error:%s\033[0m\n", taos_stmt_errstr(stmt));
  1234.       taos_stmt_close(stmt);
  1235.       exit(EXIT_FAILURE);
  1236.     }
  1238.     printf("[%d] taos_stmt_set_tbname_tags, tbname=%s\n", n, pTbName->setTbName);
  1239.     code = taos_stmt_set_tbname_tags(stmt, pTbName->setTbName, tags);
  1240.     if ((!pTbNameResult->setTbName && (0 != code)) || (pTbNameResult->setTbName && (0 == code))) {
  1241.       printf("\033[31m[%d] failed to execute taos_stmt_set_tbname_tags. error:%s\033[0m\n", n, taos_stmt_errstr(stmt));
  1242.       taos_stmt_close(stmt);
  1243.       exit(EXIT_FAILURE);
  1244.     }
  1246.     if (code == 0) {
  1247.       int64_t ts = 1591060628000 + 1000 * n;
  1248.       for (int i = 0; i < 10; ++i) {
  1249.         v.ts[i] = ts++;
  1250.         is_null[i] = 0;
  1252.         v.b[i] = (int8_t)i % 2;
  1253.         v.v1[i] = (int8_t)i;
  1254.         v.v2[i] = (int16_t)(i * 2);
  1255.         v.v4[i] = (int32_t)(i * 4);
  1256.         v.v8[i] = (int64_t)(i * 8);
  1257.         v.f4[i] = (float)(i * 40);
  1258.         v.f8[i] = (double)(i * 80);
  1259.         for (int j = 0; j < sizeof(v.bin[0]); ++j) {
  1260.           v.bin[i][j] = (char)(i + '0');
  1261.         }
  1262.         strcpy(v.blob[i], "一二三四五六七八九十");
  1263.         v.u1[i] = (uint8_t)i;
  1264.         v.u2[i] = (uint16_t)(i * 2);
  1265.         v.u4[i] = (uint32_t)(i * 4);
  1266.         v.u8[i] = (uint64_t)(i * 8);
  1268.         t8_len[i] = sizeof(int8_t);
  1269.         t16_len[i] = sizeof(int16_t);
  1270.         t32_len[i] = sizeof(int32_t);
  1271.         t64_len[i] = sizeof(int64_t);
  1272.         float_len[i] = sizeof(float);
  1273.         double_len[i] = sizeof(double);
  1274.         bin_len[i] = sizeof(v.bin[0]);
  1275.         blob_len[i] = (int32_t)strlen(v.blob[i]);
  1276.         u8_len[i] = sizeof(uint8_t);
  1277.         u16_len[i] = sizeof(uint16_t);
  1278.         u32_len[i] = sizeof(uint32_t);
  1279.         u64_len[i] = sizeof(uint64_t);
  1280.       }
  1282.       taos_stmt_bind_param_batch(stmt, params);
  1283.       taos_stmt_add_batch(stmt);
  1285.       if (taos_stmt_execute(stmt) != 0) {
  1286.         printf("\033[31m[%d] failed to execute insert statement.error:%s\033[0m\n", n, taos_stmt_errstr(stmt));
  1287.         taos_stmt_close(stmt);
  1288.         exit(EXIT_FAILURE);
  1289.       }
  1290.     }
  1291.     taos_stmt_close(stmt);
  1293.     // show the table
  1294.     printf("[%d] show tables, tbName = %s\n", n, pTbName->showName);
  1295.     stmt = taos_stmt_init(taos);
  1296.     sprintf(tmpStr, "show tables like %s", pTbName->showName);
  1297.     taos_stmt_prepare(stmt, tmpStr, 0);
  1298.     code = taos_stmt_execute(stmt);
  1299.     if ((!pTbNameResult->showName && (0 != code)) || (pTbNameResult->showName && (0 == code))) {
  1300.       printf("\033[31m[%d] failed to execute show tables like. error:%s\033[0m\n", n, taos_stmt_errstr(stmt));
  1301.       taos_stmt_close(stmt);
  1302.       exit(EXIT_FAILURE);
  1303.     }
  1304.     taos_stmt_close(stmt);
  1306.     // describe the table
  1307.     printf("[%d] describe tables, tbName = %s\n", n, pTbName->describeName);
  1308.     stmt = taos_stmt_init(taos);
  1309.     sprintf(tmpStr, "describe %s", pTbName->describeName);
  1310.     taos_stmt_prepare(stmt, tmpStr, 0);
  1311.     code = taos_stmt_execute(stmt);
  1312.     if ((!pTbNameResult->describeName && (0 != code)) || (pTbNameResult->describeName && (0 == code))) {
  1313.       printf("\033[31m[%d] failed to execute describe tables. error:%s\033[0m\n", n, taos_stmt_errstr(stmt));
  1314.       taos_stmt_close(stmt);
  1315.       exit(EXIT_FAILURE);
  1316.     }
  1317.     taos_stmt_close(stmt);
  1319.     // query the records
  1320.     printf("[%d] select statement, tbName = %s\n", n, pTbName->queryName);
  1321.     stmt = taos_stmt_init(taos);
  1322.     sprintf(tmpStr, "SELECT * FROM %s", pTbName->queryName);
  1323.     taos_stmt_prepare(stmt, tmpStr, 0);
  1325.     TAOS_BIND qparams[2];
  1327.     int8_t  v1 = 5;
  1328.     int16_t v2 = 15;
  1329.     qparams[0].buffer_type = TSDB_DATA_TYPE_TINYINT;
  1330.     qparams[0].buffer_length = sizeof(v1);
  1331.     qparams[0].buffer = &v1;
  1332.     qparams[0].length = &qparams[0].buffer_length;
  1333.     qparams[0].is_null = NULL;
  1335.     qparams[1].buffer_type = TSDB_DATA_TYPE_SMALLINT;
  1336.     qparams[1].buffer_length = sizeof(v2);
  1337.     qparams[1].buffer = &v2;
  1338.     qparams[1].length = &qparams[1].buffer_length;
  1339.     qparams[1].is_null = NULL;
  1341.     taos_stmt_bind_param(stmt, qparams);
  1343.     code = taos_stmt_execute(stmt);
  1344.     if ((!pTbNameResult->queryName && (0 != code)) || (pTbNameResult->queryName && (0 == code))) {
  1345.       printf("\033[31m[%d] failed to execute select statement.error:%s\033[0m\n", n, taos_stmt_errstr(stmt));
  1346.       taos_stmt_close(stmt);
  1347.       exit(EXIT_FAILURE);
  1348.     }
  1350.     result = taos_stmt_use_result(stmt);
  1352.     TAOS_ROW    row;
  1353.     int         rows = 0;
  1354.     int         num_fields = taos_num_fields(result);
  1355.     TAOS_FIELD* fields = taos_fetch_fields(result);
  1357.     // fetch the records row by row
  1358.     while ((row = taos_fetch_row(result))) {
  1359.       char temp[256] = {0};
  1360.       rows++;
  1361.       taos_print_row(temp, row, fields, num_fields);
  1362.       printf("[%d] row = %s\n", n, temp);
  1363.     }
  1365.     taos_free_result(result);
  1366.     taos_stmt_close(stmt);
  1368.     // drop table
  1369.     printf("[%d] drop table, tbName = %s\n", n, pTbName->dropName);
  1370.     stmt = taos_stmt_init(taos);
  1371.     sprintf(tmpStr, "drop table %s", pTbName->dropName);
  1372.     taos_stmt_prepare(stmt, tmpStr, 0);
  1373.     code = taos_stmt_execute(stmt);
  1374.     if ((!pTbNameResult->dropName && (0 != code)) || (pTbNameResult->dropName && (0 == code))) {
  1375.       printf("\033[31m[%d] failed to drop table. error:%s\033[0m\n", n, taos_stmt_errstr(stmt));
  1376.       taos_stmt_close(stmt);
  1377.       exit(EXIT_FAILURE);
  1378.     }
  1379.     taos_stmt_close(stmt);
  1380.   }
  1382.   free(t8_len);
  1383.   free(t16_len);
  1384.   free(t32_len);
  1385.   free(t64_len);
  1386.   free(float_len);
  1387.   free(double_len);
  1388.   free(bin_len);
  1389.   free(blob_len);
  1390.   free(u8_len);
  1391.   free(u16_len);
  1392.   free(u32_len);
  1393.   free(u64_len);
  1394. }
  1396. int main(int argc, char* argv[]) {
  1397.   const char* host = "127.0.0.1";
  1398.   const char* user = "root";
  1399.   const char* passwd = "taosdata";
  1401.   taos_options(TSDB_OPTION_TIMEZONE, "GMT-8");
  1402.   TAOS* taos = taos_connect(host, user, passwd, "", 0);
  1403.   if (taos == NULL) {
  1404.     printf("\033[31mfailed to connect to db, reason:%s\033[0m\n", taos_errstr(taos));
  1405.     exit(1);
  1406.   }
  1408.   char* info = taos_get_server_info(taos);
  1409.   printf("server info: %s\n", info);
  1410.   info = taos_get_client_info(taos);
  1411.   printf("client info: %s\n", info);
  1412.   printf("************  verify prepare  *************\n");
  1413.   verify_prepare(taos);
  1414.   printf("************  verify prepare2  *************\n");
  1415.   verify_prepare2(taos);
  1416.   printf("************  verify prepare3  *************\n");
  1417.   verify_prepare3(taos);
  1418.   printf("************  verify prepare4  *************\n");
  1419.   verify_prepare4(taos);
  1420.   printf("************  verify end  *************\n");
  1421.   exit(EXIT_SUCCESS);
  1422. }

查看源码

无模式写入示例

无模式写入

  1. #include "os.h"
  2. #include "taos.h"
  3. #include "taoserror.h"
  5. #include <stdio.h>
  6. #include <stdlib.h>
  7. #include <sys/time.h>
  8. #include <time.h>
  9. #include <unistd.h>
  11. bool verbose = false;
  14. void printThreadId(pthread_t id, char* buf)
  15. {
  16.   size_t i;
  17.   for (i = sizeof(i); i; --i)
  18.     sprintf(buf + strlen(buf), "%02x", *(((unsigned char*) &id) + i - 1));
  19. }
  21. static int64_t getTimeInUs() {
  22.   struct timeval systemTime;
  23.   gettimeofday(&systemTime, NULL);
  24.   return (int64_t)systemTime.tv_sec * 1000000L + (int64_t)systemTime.tv_usec;
  25. }
  27. typedef struct {
  28.   char** lines;
  29.   int numLines;
  30. } SThreadLinesBatch;
  32. typedef struct  {
  33.   TAOS* taos;
  34.   int protocol;
  35.   int numBatches;
  36.   SThreadLinesBatch *batches;
  37.   int64_t costTime;
  38. } SThreadInsertArgs;
  40. static void* insertLines(void* args) {
  41.   SThreadInsertArgs* insertArgs = (SThreadInsertArgs*) args;
  42.   char tidBuf[32] = {0};
  43.   printThreadId(pthread_self(), tidBuf);
  44.   for (int i = 0; i < insertArgs->numBatches; ++i) {
  45.     SThreadLinesBatch* batch = insertArgs->batches + i;
  46.     if (verbose) printf("%s, thread: 0x%s\n", "begin taos_insert_lines", tidBuf);
  47.     int64_t begin = getTimeInUs();
  48.     //int32_t code = taos_insert_lines(insertArgs->taos, batch->lines, batch->numLines);
  49.     TAOS_RES * res = taos_schemaless_insert(insertArgs->taos, batch->lines, batch->numLines, insertArgs->protocol, TSDB_SML_TIMESTAMP_MILLI_SECONDS);
  50.     int32_t code = taos_errno(res);
  51.     int64_t end = getTimeInUs();
  52.     insertArgs->costTime += end - begin;
  53.     if (verbose) printf("code: %d, %s. time used:%"PRId64", thread: 0x%s\n", code, tstrerror(code), end - begin, tidBuf);
  54.   }
  55.   return NULL;
  56. }
  58. int32_t getTelenetTemplate(char* lineTemplate, int templateLen) {
  59.   char* sample = "sta%d %lld 44.3 t0=False t1=127i8 t2=32 t3=%di32 t4=9223372036854775807i64 t5=11.12345f32 t6=22.123456789f64 t7=\"hpxzrdiw\" t8=\"ncharTagValue\" t9=127i8";
  60.   snprintf(lineTemplate, templateLen, "%s", sample);
  61.   return 0;
  62. }
  64. int32_t getLineTemplate(char* lineTemplate, int templateLen, int numFields) {
  65.   if (numFields <= 4) {
  66.     char* sample = "sta%d,t3=%di32 c3=2147483647i32,c4=9223372036854775807i64,c9=11.12345f32,c10=22.123456789f64 %lld";
  67.     snprintf(lineTemplate, templateLen, "%s", sample);
  68.     return 0;
  69.   }
  71.   if (numFields <= 13) {
  72.      char* sample = "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=254u8,c6=32770u16,c7=2147483699u32,c8=9223372036854775899u64,c9=11.12345f32,c10=22.123456789f64,c11=\"binaryValue\",c12=L\"ncharValue\" %lld";
  73.      snprintf(lineTemplate, templateLen, "%s", sample);
  74.      return 0;
  75.   }
  77.   char* lineFormatTable = "sta%d,t0=true,t1=127i8,t2=32767i16,t3=%di32 ";
  78.   snprintf(lineTemplate+strlen(lineTemplate), templateLen-strlen(lineTemplate), "%s", lineFormatTable);
  80.   int offset[] = {numFields*2/5, numFields*4/5, numFields};
  82.   for (int i = 0; i < offset[0]; ++i) {
  83.     snprintf(lineTemplate+strlen(lineTemplate), templateLen-strlen(lineTemplate), "c%d=%di32,", i, i);
  84.   }
  86.   for (int i=offset[0]+1; i < offset[1]; ++i) {
  87.     snprintf(lineTemplate+strlen(lineTemplate), templateLen-strlen(lineTemplate), "c%d=%d.43f64,", i, i);
  88.   }
  90.   for (int i = offset[1]+1; i < offset[2]; ++i) {
  91.     snprintf(lineTemplate+strlen(lineTemplate), templateLen-strlen(lineTemplate), "c%d=\"%d\",", i, i);
  92.   }
  93.   char* lineFormatTs = " %lld";
  94.   snprintf(lineTemplate+strlen(lineTemplate)-1, templateLen-strlen(lineTemplate)+1, "%s", lineFormatTs);
  96.   return 0;
  97. }
  99. int32_t generateLine(char* line, int lineLen, char* lineTemplate, int protocol, int superTable, int childTable, int64_t ts) {
  100.   if (protocol == TSDB_SML_LINE_PROTOCOL) {
  101.     snprintf(line, lineLen, lineTemplate, superTable, childTable, ts);               
  102.   } else if (protocol == TSDB_SML_TELNET_PROTOCOL) {
  103.     snprintf(line, lineLen, lineTemplate, superTable, ts, childTable);
  104.   }
  105.   return TSDB_CODE_SUCCESS;
  106. }
  108. int32_t setupSuperTables(TAOS* taos, char* lineTemplate, int protocol,
  109.                          int numSuperTables, int numChildTables, int numRowsPerChildTable,
  110.                          int maxBatchesPerThread, int64_t ts) {
  111.   printf("setup supertables...");
  112.   {
  113.     char** linesStb = calloc(numSuperTables, sizeof(char*));
  114.     for (int i = 0; i < numSuperTables; i++) {
  115.       char* lineStb = calloc(strlen(lineTemplate)+128, 1);
  116.       generateLine(lineStb, strlen(lineTemplate)+128, lineTemplate, protocol, i,
  117.                    numSuperTables * numChildTables,
  118.                    ts + numSuperTables * numChildTables * numRowsPerChildTable);
  119.       linesStb[i] = lineStb;
  120.     }
  121.     SThreadInsertArgs args = {0};
  122.     args.protocol = protocol;
  123.     args.batches = calloc(maxBatchesPerThread, sizeof(maxBatchesPerThread));
  124.     args.taos = taos;
  125.     args.batches[0].lines = linesStb;
  126.     args.batches[0].numLines = numSuperTables;
  127.     insertLines(&args);
  128.     free(args.batches);
  129.     for (int i = 0; i < numSuperTables; ++i) {
  130.       free(linesStb[i]);
  131.     }
  132.     free(linesStb);
  133.   }
  134.   return TSDB_CODE_SUCCESS;
  135. }
  137. int main(int argc, char* argv[]) {
  138.   int numThreads = 8;
  139.   int maxBatchesPerThread = 1024;   
  141.   int numSuperTables = 1;
  142.   int numChildTables = 256;
  143.   int numRowsPerChildTable = 8192;
  144.   int numFields = 13;
  146.   int maxLinesPerBatch = 16384;
  148.   int protocol = TSDB_SML_TELNET_PROTOCOL;
  149.   int assembleSTables = 0;
  151.   int opt;
  152.   while ((opt = getopt(argc, argv, "s:c:r:f:t:b:p:w:hv")) != -1) {
  153.     switch (opt) {
  154.       case 's':
  155.         numSuperTables = atoi(optarg);
  156.         break;
  157.       case 'c':
  158.         numChildTables = atoi(optarg);
  159.         break;
  160.       case 'r':
  161.         numRowsPerChildTable = atoi(optarg);
  162.         break;
  163.       case 'f':
  164.         numFields = atoi(optarg);
  165.         break;
  166.       case 't':
  167.         numThreads = atoi(optarg);
  168.         break;
  169.       case 'b':
  170.         maxLinesPerBatch = atoi(optarg);
  171.         break;
  172.       case 'v':
  173.         verbose = true;
  174.         break;
  175.       case 'a':
  176.         assembleSTables = atoi(optarg);
  177.         break;
  178.       case 'p':
  179.         if (optarg[0] == 't') {
  180.           protocol = TSDB_SML_TELNET_PROTOCOL;
  181.         } else if (optarg[0] == 'l') {
  182.           protocol = TSDB_SML_LINE_PROTOCOL;
  183.         } else if (optarg[0] == 'j') {
  184.           protocol = TSDB_SML_JSON_PROTOCOL;
  185.         }
  186.         break;
  187.       case 'h':
  188.         fprintf(stderr, "Usage: %s -s supertable -c childtable -r rows -f fields -t threads -b maxlines_per_batch -p [t|l|j] -a assemble-stables -v\n",
  189.                 argv[0]);
  190.         exit(0);
  191.       default: /* '?' */
  192.         fprintf(stderr, "Usage: %s -s supertable -c childtable -r rows -f fields -t threads -b maxlines_per_batch -p [t|l|j] -a assemble-stables -v\n",
  193.                 argv[0]);
  194.         exit(-1);
  195.     }
  196.   }
  198.   TAOS_RES*   result;
  199.   //const char* host = "127.0.0.1";
  200.   const char* host = NULL;
  201.   const char* user = "root";
  202.   const char* passwd = "taosdata";
  204.   taos_options(TSDB_OPTION_TIMEZONE, "GMT-8");
  205.   TAOS* taos = taos_connect(host, user, passwd, "", 0);
  206.   if (taos == NULL) {
  207.     printf("\033[31mfailed to connect to db, reason:%s\033[0m\n", taos_errstr(taos));
  208.     exit(1);
  209.   }
  211.   maxBatchesPerThread = (numSuperTables*numChildTables*numRowsPerChildTable)/(numThreads * maxLinesPerBatch) + 1;
  213.   char* info = taos_get_server_info(taos);
  214.   printf("server info: %s\n", info);
  215.   info = taos_get_client_info(taos);
  216.   printf("client info: %s\n", info);
  217.   result = taos_query(taos, "drop database if exists db;");
  218.   taos_free_result(result);
  219.   usleep(100000);
  220.   result = taos_query(taos, "create database db precision 'us';");
  221.   taos_free_result(result);
  222.   usleep(100000);
  224.   (void)taos_select_db(taos, "db");
  226.   time_t  ct = time(0);
  227.   int64_t ts = ct * 1000 ;
  229.   char* lineTemplate = calloc(65536, sizeof(char));
  230.   if (protocol == TSDB_SML_LINE_PROTOCOL) {
  231.     getLineTemplate(lineTemplate, 65535, numFields);
  232.   } else if (protocol == TSDB_SML_TELNET_PROTOCOL ) {
  233.     getTelenetTemplate(lineTemplate, 65535);
  234.   }
  236.   if (assembleSTables) {
  237.     setupSuperTables(taos, lineTemplate, protocol,
  238.                      numSuperTables, numChildTables, numRowsPerChildTable, maxBatchesPerThread, ts);
  239.   }
  241.   printf("generate lines...\n");
  242.   pthread_t* tids = calloc(numThreads, sizeof(pthread_t));
  243.   SThreadInsertArgs* argsThread = calloc(numThreads, sizeof(SThreadInsertArgs));
  244.   for (int i = 0; i < numThreads; ++i) {
  245.     argsThread[i].batches = calloc(maxBatchesPerThread, sizeof(SThreadLinesBatch));   
  246.     argsThread[i].taos = taos;
  247.     argsThread[i].numBatches = 0;
  248.     argsThread[i].protocol = protocol;
  249.   }
  251.   int64_t totalLines = numSuperTables * numChildTables * numRowsPerChildTable;
  252.   int totalBatches = (int) ((totalLines) / maxLinesPerBatch);
  253.   if (totalLines % maxLinesPerBatch != 0) {
  254.     totalBatches += 1;
  255.   }
  257.   char*** allBatches = calloc(totalBatches, sizeof(char**));
  258.   for (int i = 0; i < totalBatches; ++i) {
  259.     allBatches[i] = calloc(maxLinesPerBatch, sizeof(char*));
  260.     int threadNo = i % numThreads;
  261.     int batchNo = i / numThreads;
  262.     argsThread[threadNo].batches[batchNo].lines = allBatches[i];
  263.     argsThread[threadNo].numBatches = batchNo + 1;
  264.   }
  266.   int l = 0;
  267.   for (int i = 0; i < numSuperTables; ++i) {
  268.     for (int j = 0; j < numChildTables; ++j) {
  269.       for (int k = 0; k < numRowsPerChildTable; ++k) {
  270.         int stIdx = i;
  271.         int ctIdx = numSuperTables*numChildTables + j;
  272.         char* line = calloc(strlen(lineTemplate)+128, 1);
  273.         generateLine(line, strlen(lineTemplate)+128, lineTemplate, protocol, stIdx, ctIdx, ts + l);
  274.         int batchNo = l / maxLinesPerBatch;
  275.         int lineNo = l % maxLinesPerBatch;
  276.         allBatches[batchNo][lineNo] =  line;
  277.         argsThread[batchNo % numThreads].batches[batchNo/numThreads].numLines = lineNo + 1;
  278.         ++l;
  279.       }
  280.     }
  281.   }
  283.   printf("begin multi-thread insertion...\n");
  284.   int64_t begin = taosGetTimestampUs();
  286.   for (int i=0; i < numThreads; ++i) {
  287.     pthread_create(tids+i, NULL, insertLines, argsThread+i);
  288.   }
  289.   for (int i = 0; i < numThreads; ++i) {
  290.     pthread_join(tids[i], NULL);
  291.   }
  292.   int64_t end = taosGetTimestampUs();
  294.   size_t linesNum = numSuperTables*numChildTables*numRowsPerChildTable;
  295.   printf("TOTAL LINES: %zu\n", linesNum);
  296.   printf("THREADS: %d\n", numThreads);
  297.   printf("TIME: %d(ms)\n", (int)(end-begin)/1000);
  298.   double throughput = (double)(totalLines)/(double)(end-begin) * 1000000;
  299.   printf("THROUGHPUT:%d/s\n", (int)throughput);
  301.   for (int i = 0; i < totalBatches; ++i) {
  302.     free(allBatches[i]);
  303.   }
  304.   free(allBatches);
  306.   for (int i = 0; i < numThreads; i++) {
  307.     free(argsThread[i].batches);
  308.   }    
  309.   free(argsThread);
  310.   free(tids);
  312.   free(lineTemplate);
  313.   taos_close(taos);
  314.   return 0;
  315. }

查看源码

订阅和消费示例

订阅和消费

// sample code for TDengine subscribe/consume API
// to compile: gcc -o subscribe subscribe.c -ltaos

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <taos.h>  // include TDengine header file
#include <unistd.h>

int nTotalRows;

void print_result(TAOS_RES* res, int blockFetch) {
  TAOS_ROW    row = NULL;
  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++) {
    //  taos_print_row(buf, row + i, fields, num_fields);
    //  puts(buf);
    //}
  } else {
    while ((row = taos_fetch_row(res))) {
      char buf[4096] = {0};
      taos_print_row(buf, row, fields, num_fields);
      puts(buf);
      nRows++;
    }
  }

  nTotalRows += nRows;
  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 check_row_count(int line, TAOS_RES* res, int expected) {
  int      actual = 0;
  TAOS_ROW row;
  while ((row = taos_fetch_row(res))) {
    actual++;
  }
  if (actual != expected) {
    printf("line %d: row count mismatch, expected: %d, actual: %d\n", line, expected, actual);
  } else {
    printf("line %d: %d rows consumed as expected\n", line, actual);
  }
}

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);
  do_query(taos, "use test;");

  usleep(100000);
  do_query(taos, "create table meters(ts timestamp, a int) tags(area int);");

  do_query(taos, "create table t0 using meters tags(0);");
  do_query(taos, "create table t1 using meters tags(1);");
  do_query(taos, "create table t2 using meters tags(2);");
  do_query(taos, "create table t3 using meters tags(3);");
  do_query(taos, "create table t4 using meters tags(4);");
  do_query(taos, "create table t5 using meters tags(5);");
  do_query(taos, "create table t6 using meters tags(6);");
  do_query(taos, "create table t7 using meters tags(7);");
  do_query(taos, "create table t8 using meters tags(8);");
  do_query(taos, "create table t9 using meters tags(9);");

  do_query(taos, "insert into t0 values('2020-01-01 00:00:00.000', 0);");
  do_query(taos, "insert into t0 values('2020-01-01 00:01:00.000', 0);");
  do_query(taos, "insert into t0 values('2020-01-01 00:02:00.000', 0);");
  do_query(taos, "insert into t1 values('2020-01-01 00:00:00.000', 0);");
  do_query(taos, "insert into t1 values('2020-01-01 00:01:00.000', 0);");
  do_query(taos, "insert into t1 values('2020-01-01 00:02:00.000', 0);");
  do_query(taos, "insert into t1 values('2020-01-01 00:03:00.000', 0);");
  do_query(taos, "insert into t2 values('2020-01-01 00:00:00.000', 0);");
  do_query(taos, "insert into t2 values('2020-01-01 00:01:00.000', 0);");
  do_query(taos, "insert into t2 values('2020-01-01 00:01:01.000', 0);");
  do_query(taos, "insert into t2 values('2020-01-01 00:01:02.000', 0);");
  do_query(taos, "insert into t3 values('2020-01-01 00:01:02.000', 0);");
  do_query(taos, "insert into t4 values('2020-01-01 00:01:02.000', 0);");
  do_query(taos, "insert into t5 values('2020-01-01 00:01:02.000', 0);");
  do_query(taos, "insert into t6 values('2020-01-01 00:01:02.000', 0);");
  do_query(taos, "insert into t7 values('2020-01-01 00:01:02.000', 0);");
  do_query(taos, "insert into t8 values('2020-01-01 00:01:02.000', 0);");
  do_query(taos, "insert into t9 values('2020-01-01 00:01:02.000', 0);");

  // super tables subscription
  usleep(1000000);

  TAOS_SUB* tsub = taos_subscribe(taos, 0, "test", "select * from meters;", NULL, NULL, 0);
  TAOS_RES* res = taos_consume(tsub);
  check_row_count(__LINE__, res, 18);

  res = taos_consume(tsub);
  check_row_count(__LINE__, res, 0);

  do_query(taos, "insert into t0 values('2020-01-01 00:02:00.001', 0);");
  do_query(taos, "insert into t8 values('2020-01-01 00:01:03.000', 0);");
  res = taos_consume(tsub);
  check_row_count(__LINE__, res, 2);

  do_query(taos, "insert into t2 values('2020-01-01 00:01:02.001', 0);");
  do_query(taos, "insert into t1 values('2020-01-01 00:03:00.001', 0);");
  res = taos_consume(tsub);
  check_row_count(__LINE__, res, 2);

  do_query(taos, "insert into t1 values('2020-01-01 00:03:00.002', 0);");
  res = taos_consume(tsub);
  check_row_count(__LINE__, res, 1);

  // keep progress information and restart subscription
  taos_unsubscribe(tsub, 1);
  do_query(taos, "insert into t0 values('2020-01-01 00:04:00.000', 0);");
  tsub = taos_subscribe(taos, 1, "test", "select * from meters;", NULL, NULL, 0);
  res = taos_consume(tsub);
  check_row_count(__LINE__, res, 24);

  // keep progress information and continue previous subscription
  taos_unsubscribe(tsub, 1);
  tsub = taos_subscribe(taos, 0, "test", "select * from meters;", NULL, NULL, 0);
  res = taos_consume(tsub);
  check_row_count(__LINE__, res, 0);

  // don't keep progress information and continue previous subscription
  taos_unsubscribe(tsub, 0);
  tsub = taos_subscribe(taos, 0, "test", "select * from meters;", NULL, NULL, 0);
  res = taos_consume(tsub);
  check_row_count(__LINE__, res, 24);

  // single meter subscription

  taos_unsubscribe(tsub, 0);
  tsub = taos_subscribe(taos, 0, "test", "select * from t0;", NULL, NULL, 0);
  res = taos_consume(tsub);
  check_row_count(__LINE__, res, 5);

  res = taos_consume(tsub);
  check_row_count(__LINE__, res, 0);

  do_query(taos, "insert into t0 values('2020-01-01 00:04:00.001', 0);");
  res = taos_consume(tsub);
  check_row_count(__LINE__, res, 1);

  taos_unsubscribe(tsub, 0);
}

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;

  for (int i = 1; i < argc; i++) {
    if (strncmp(argv[i], "-h=", 3) == 0) {
      host = argv[i] + 3;
      continue;
    }
    if (strncmp(argv[i], "-u=", 3) == 0) {
      user = argv[i] + 3;
      continue;
    }
    if (strncmp(argv[i], "-p=", 3) == 0) {
      passwd = argv[i] + 3;
      continue;
    }
    if (strcmp(argv[i], "-sync") == 0) {
      async = 0;
      continue;
    }
    if (strcmp(argv[i], "-restart") == 0) {
      restart = 1;
      continue;
    }
    if (strcmp(argv[i], "-single") == 0) {
      sql = "select * from t0;";
      topic = "test-single";
      continue;
    }
    if (strcmp(argv[i], "-nokeep") == 0) {
      keep = 0;
      continue;
    }
    if (strncmp(argv[i], "-sql=", 5) == 0) {
      sql = argv[i] + 5;
      topic = "test-custom";
      continue;
    }
    if (strcmp(argv[i], "-test") == 0) {
      test = 1;
      continue;
    }
    if (strcmp(argv[i], "-block-fetch") == 0) {
      blockFetch = 1;
      continue;
    }
  }

  TAOS* taos = taos_connect(host, user, passwd, "", 0);
  if (taos == NULL) {
    printf("failed to connect to db, reason:%s\n", taos_errstr(taos));
    exit(1);
  }

  if (test) {
    run_test(taos);
    taos_close(taos);
    exit(0);
  }

  taos_select_db(taos, "test");
  TAOS_SUB* tsub = NULL;
  if (async) {
    // create an asynchronized subscription, the callback function will be called every 1s
    tsub = taos_subscribe(taos, restart, topic, sql, subscribe_callback, &blockFetch, 1000);
  } else {
    // create an synchronized subscription, need to call 'taos_consume' manually
    tsub = taos_subscribe(taos, restart, topic, sql, NULL, NULL, 0);
  }

  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();
      }
    }

  printf("total rows consumed: %d\n", nTotalRows);
  taos_unsubscribe(tsub, keep);
  taos_close(taos);

  return 0;
}

查看源码

C/C++ - 图2info

更多示例代码及下载请见 GitHub。 也可以在安装目录下的 examples/c 路径下找到。 该目录下有 makefile，在 Linux 环境下，直接执行 make 就可以编译得到执行文件。 提示：在 ARM 环境下编译时，请将 makefile 中的 -msse4.2 去掉，这个选项只有在 x64/x86 硬件平台上才能支持。

API 参考

以下分别介绍 TDengine 客户端驱动的基础 API、同步 API、异步 API、订阅 API 和无模式写入 API。

基础 API

基础 API 用于完成创建数据库连接等工作，为其它 API 的执行提供运行时环境。

  • void taos_init()

    初始化运行环境。如果没有主动调用该 API，那么调用 taos_connect() 时驱动将自动调用该 API，故程序一般无需手动调用。

  • void taos_cleanup()

    清理运行环境，应用退出前应调用。

  • int taos_options(TSDB_OPTION option, const void * arg, ...)

    设置客户端选项，目前支持区域设置（TSDB_OPTION_LOCALE）、字符集设置（TSDB_OPTION_CHARSET）、时区设置（TSDB_OPTION_TIMEZONE）、配置文件路径设置（TSDB_OPTION_CONFIGDIR）。区域设置、字符集、时区默认为操作系统当前设置。

  • char *taos_get_client_info()

    获取客户端版本信息。

  • TAOS *taos_connect(const char *host, const char *user, const char *pass, const char *db, int port)

    创建数据库连接，初始化连接上下文。其中需要用户提供的参数包含：

    • host：TDengine 集群中任一节点的 FQDN
    • user：用户名
    • pass：密码
    • db： 数据库名字，如果用户没有提供，也可以正常连接，用户可以通过该连接创建新的数据库，如果用户提供了数据库名字，则说明该数据库用户已经创建好，缺省使用该数据库
    • port：taosd 程序监听的端口

    返回值为空表示失败。应用程序需要保存返回的参数，以便后续使用。

    C/C++ - 图3info

    同一进程可以根据不同的 host/port 连接多个 TDengine 集群

  • char *taos_get_server_info(TAOS *taos)

    获取服务端版本信息。

  • int taos_select_db(TAOS *taos, const char *db)

    将当前的缺省数据库设置为 db。

  • void taos_close(TAOS *taos)

    关闭连接，其中taos是 taos_connect() 返回的句柄。

同步查询 API

本小节介绍 API 均属于同步接口。应用调用后，会阻塞等待响应，直到获得返回结果或错误信息。

  • TAOS_RES* taos_query(TAOS *taos, const char *sql)

    执行 SQL 语句，可以是 DQL、DML 或 DDL 语句。 其中的 taos 参数是通过 taos_connect() 获得的句柄。不能通过返回值是否是 NULL 来判断执行结果是否失败，而是需要用 taos_errno() 函数解析结果集中的错误代码来进行判断。

  • int taos_result_precision(TAOS_RES *res)

    返回结果集时间戳字段的精度，0 代表毫秒，1 代表微秒，2 代表纳秒。

  • TAOS_ROW taos_fetch_row(TAOS_RES *res)

    按行获取查询结果集中的数据。

  • int taos_fetch_block(TAOS_RES *res, TAOS_ROW *rows)

    批量获取查询结果集中的数据，返回值为获取到的数据的行数。

  • int taos_num_fields(TAOS_RES *res) 和 int taos_field_count(TAOS_RES *res)

    这两个 API 等价，用于获取查询结果集中的列数。

  • int* taos_fetch_lengths(TAOS_RES *res)

    获取结果集中每个字段的长度。返回值是一个数组，其长度为结果集的列数。

  • int taos_affected_rows(TAOS_RES *res)

    获取被所执行的 SQL 语句影响的行数。

  • TAOS_FIELD *taos_fetch_fields(TAOS_RES *res)

    获取查询结果集每列数据的属性（列的名称、列的数据类型、列的长度），与 taos_num_fileds() 配合使用，可用来解析 taos_fetch_row() 返回的一个元组(一行)的数据。 TAOS_FIELD 的结构如下：

typedef struct taosField {
  char     name[65];  // column name
  uint8_t  type;      // data type
  int16_t  bytes;     // length, in bytes
} TAOS_FIELD;

  • void taos_stop_query(TAOS_RES *res)

    停止当前查询的执行。

  • void taos_free_result(TAOS_RES *res)

    释放查询结果集以及相关的资源。查询完成后，务必调用该 API 释放资源，否则可能导致应用内存泄露。但也需注意，释放资源后，如果再调用 taos_consume() 等获取查询结果的函数，将导致应用崩溃。

  • char *taos_errstr(TAOS_RES *res)

    获取最近一次 API 调用失败的原因,返回值为字符串标识的错误提示信息。

  • int taos_errno(TAOS_RES *res)

    获取最近一次 API 调用失败的原因，返回值为错误代码。

C/C++ - 图4note

2.0 及以上版本 TDengine 推荐数据库应用的每个线程都建立一个独立的连接，或基于线程建立连接池。而不推荐在应用中将该连接 (TAOS*) 结构体传递到不同的线程共享使用。基于 TAOS 结构体发出的查询、写入等操作具有多线程安全性，但 “USE statement” 等状态量有可能在线程之间相互干扰。此外，C 语言的连接器可以按照需求动态建立面向数据库的新连接（该过程对用户不可见），同时建议只有在程序最后退出的时候才调用 taos_close() 关闭连接。

异步查询 API

TDengine 还提供性能更高的异步 API 处理数据插入、查询操作。在软硬件环境相同的情况下，异步 API 处理数据插入的速度比同步 API 快 2 ～ 4 倍。异步 API 采用非阻塞式的调用方式，在系统真正完成某个具体数据库操作前，立即返回。调用的线程可以去处理其他工作，从而可以提升整个应用的性能。异步 API 在网络延迟严重的情况下，优势尤为突出。

异步 API 都需要应用提供相应的回调函数，回调函数参数设置如下：前两个参数都是一致的，第三个参数依不同的 API 而定。第一个参数 param 是应用调用异步 API 时提供给系统的，用于回调时，应用能够找回具体操作的上下文，依具体实现而定。第二个参数是 SQL 操作的结果集，如果为空，比如 insert 操作，表示没有记录返回，如果不为空，比如 select 操作，表示有记录返回。

异步 API 对于使用者的要求相对较高，用户可根据具体应用场景选择性使用。下面是两个重要的异步 API：

  • void taos_query_a(TAOS *taos, const char *sql, void (*fp)(void *param, TAOS_RES *, int code), void *param);

    异步执行 SQL 语句。

    • taos：调用 taos_connect() 返回的数据库连接
    • sql：需要执行的 SQL 语句
    • fp：用户定义的回调函数，其第三个参数 code 用于指示操作是否成功，0 表示成功，负数表示失败（调用 taos_errstr() 可获取失败原因）。应用在定义回调函数的时候，主要处理第二个参数 TAOS_RES *，该参数是查询返回的结果集
    • param：应用提供一个用于回调的参数

  • void taos_fetch_rows_a(TAOS_RES *res, void (*fp)(void *param, TAOS_RES *, int numOfRows), void *param);

    批量获取异步查询的结果集，只能与 taos_query_a() 配合使用。其中：

    • res：taos_query_a() 回调时返回的结果集
    • fp：回调函数。其参数 param 是用户可定义的传递给回调函数的参数结构体；numOfRows 是获取到的数据的行数（不是整个查询结果集的函数）。 在回调函数中，应用可以通过调用 taos_fetch_row() 前向迭代获取批量记录中每一行记录。读完一块内的所有记录后，应用需要在回调函数中继续调用 taos_fetch_rows_a() 获取下一批记录进行处理，直到返回的记录数 numOfRows 为零（结果返回完成）或记录数为负值（查询出错）。

TDengine 的异步 API 均采用非阻塞调用模式。应用程序可以用多线程同时打开多张表，并可以同时对每张打开的表进行查询或者插入操作。需要指出的是，客户端应用必须确保对同一张表的操作完全串行化，即对同一个表的插入或查询操作未完成时（未返回时），不能够执行第二个插入或查询操作。

参数绑定 API

除了直接调用 taos_query() 进行查询，TDengine 也提供了支持参数绑定的 Prepare API，风格与 MySQL 类似，目前也仅支持用问号 ? 来代表待绑定的参数。

从 2.1.1.0 和 2.1.2.0 版本开始，TDengine 大幅改进了参数绑定接口对数据写入（INSERT）场景的支持。这样在通过参数绑定接口写入数据时，就避免了 SQL 语法解析的资源消耗，从而在绝大多数情况下显著提升写入性能。此时的典型操作步骤如下：

  1. 调用 taos_stmt_init() 创建参数绑定对象；
  2. 调用 taos_stmt_prepare() 解析 INSERT 语句；
  3. 如果 INSERT 语句中预留了表名但没有预留 TAGS，那么调用 taos_stmt_set_tbname() 来设置表名；
  4. 如果 INSERT 语句中既预留了表名又预留了 TAGS（例如 INSERT 语句采取的是自动建表的方式），那么调用 taos_stmt_set_tbname_tags() 来设置表名和 TAGS 的值；
  5. 调用 taos_stmt_bind_param_batch() 以多行的方式设置 VALUES 的值，或者调用 taos_stmt_bind_param() 以单行的方式设置 VALUES 的值；
  6. 调用 taos_stmt_add_batch() 把当前绑定的参数加入批处理；
  7. 可以重复第 3 ～ 6 步，为批处理加入更多的数据行；
  8. 调用 taos_stmt_execute() 执行已经准备好的批处理指令；
  9. 执行完毕，调用 taos_stmt_close() 释放所有资源。

说明：如果 taos_stmt_execute() 执行成功，假如不需要改变 SQL 语句的话，那么是可以复用 taos_stmt_prepare() 的解析结果，直接进行第 3 ～ 6 步绑定新数据的。但如果执行出错，那么并不建议继续在当前的环境上下文下继续工作，而是建议释放资源，然后从 taos_stmt_init() 步骤重新开始。

接口相关的具体函数如下（也可以参考 prepare.c 文件中使用对应函数的方式）：

  • TAOS_STMT* taos_stmt_init(TAOS *taos)

    创建一个 TAOS_STMT 对象用于后续调用。

  • int taos_stmt_prepare(TAOS_STMT *stmt, const char *sql, unsigned long length)

    解析一条 SQL 语句，将解析结果和参数信息绑定到 stmt 上，如果参数 length 大于 0，将使用此参数作为 SQL 语句的长度，如等于 0，将自动判断 SQL 语句的长度。

  • int taos_stmt_bind_param(TAOS_STMT *stmt, TAOS_BIND *bind)

    不如 taos_stmt_bind_param_batch() 效率高，但可以支持非 INSERT 类型的 SQL 语句。 进行参数绑定，bind 指向一个数组（代表所要绑定的一行数据），需保证此数组中的元素数量和顺序与 SQL 语句中的参数完全一致。TAOS_BIND 的使用方法与 MySQL 中的 MYSQL_BIND 类似，具体定义如下：

    typedef struct TAOS_BIND {
  int            buffer_type;
  void *         buffer;
  uintptr_t      buffer_length;  // not in use
  uintptr_t *    length;
  int *          is_null;
  int            is_unsigned;    // not in use
  int *          error;          // not in use
} TAOS_BIND;

  • int taos_stmt_set_tbname(TAOS_STMT* stmt, const char* name)

    （2.1.1.0 版本新增，仅支持用于替换 INSERT 语句中的参数值） 当 SQL 语句中的表名使用了 ? 占位时，可以使用此函数绑定一个具体的表名。

  • int taos_stmt_set_tbname_tags(TAOS_STMT* stmt, const char* name, TAOS_BIND* tags)

    （2.1.2.0 版本新增，仅支持用于替换 INSERT 语句中的参数值） 当 SQL 语句中的表名和 TAGS 都使用了 ? 占位时，可以使用此函数绑定具体的表名和具体的 TAGS 取值。最典型的使用场景是使用了自动建表功能的 INSERT 语句（目前版本不支持指定具体的 TAGS 列）。TAGS 参数中的列数量需要与 SQL 语句中要求的 TAGS 数量完全一致。

  • int taos_stmt_bind_param_batch(TAOS_STMT* stmt, TAOS_MULTI_BIND* bind)

    （2.1.1.0 版本新增，仅支持用于替换 INSERT 语句中的参数值） 以多列的方式传递待绑定的数据，需要保证这里传递的数据列的顺序、列的数量与 SQL 语句中的 VALUES 参数完全一致。TAOS_MULTI_BIND 的具体定义如下：

    typedef struct TAOS_MULTI_BIND {
  int          buffer_type;
  void *       buffer;
  uintptr_t    buffer_length;
  uintptr_t *  length;
  char *       is_null;
  int          num;             // the number of columns
} TAOS_MULTI_BIND;

  • int taos_stmt_add_batch(TAOS_STMT *stmt)

    将当前绑定的参数加入批处理中，调用此函数后，可以再次调用 taos_stmt_bind_param() 或 taos_stmt_bind_param_batch() 绑定新的参数。需要注意，此函数仅支持 INSERT/IMPORT 语句，如果是 SELECT 等其他 SQL 语句，将返回错误。

  • int taos_stmt_execute(TAOS_STMT *stmt)

    执行准备好的语句。目前，一条语句只能执行一次。

  • TAOS_RES* taos_stmt_use_result(TAOS_STMT *stmt)

    获取语句的结果集。结果集的使用方式与非参数化调用时一致，使用完成后，应对此结果集调用 taos_free_result() 以释放资源。

  • int taos_stmt_close(TAOS_STMT *stmt)

    执行完毕，释放所有资源。

  • char * taos_stmt_errstr(TAOS_STMT *stmt)

    （2.1.3.0 版本新增） 用于在其他 STMT API 返回错误（返回错误码或空指针）时获取错误信息。

无模式（schemaless）写入 API

除了使用 SQL 方式或者使用参数绑定 API 写入数据外，还可以使用 Schemaless 的方式完成写入。Schemaless 可以免于预先创建超级表/数据子表的数据结构，而是可以直接写入数据，TDengine 系统会根据写入的数据内容自动创建和维护所需要的表结构。Schemaless 的使用方式详见 Schemaless 写入 章节，这里介绍与之配套使用的 C/C++ API。

  • TAOS_RES* taos_schemaless_insert(TAOS* taos, const char* lines[], int numLines, int protocol, int precision)

    功能说明 该接口将行协议的文本数据写入到 TDengine 中。

    参数说明 taos: 数据库连接，通过 taos_connect() 函数建立的数据库连接。 lines：文本数据。满足解析格式要求的无模式文本字符串。 numLines:文本数据的行数，不能为 0 。 protocol: 行协议类型，用于标识文本数据格式。 precision：文本数据中的时间戳精度字符串。

    返回值 TAOS_RES 结构体，应用可以通过使用 taos_errstr() 获得错误信息，也可以使用 taos_errno() 获得错误码。 在某些情况下，返回的 TAOS_RES 为 NULL，此时仍然可以调用 taos_errno() 来安全地获得错误码信息。 返回的 TAOS_RES 需要调用方来负责释放，否则会出现内存泄漏。

    说明 协议类型是枚举类型，包含以下三种格式：

    • TSDB_SML_LINE_PROTOCOL：InfluxDB 行协议（Line Protocol)
    • TSDB_SML_TELNET_PROTOCOL: OpenTSDB Telnet 文本行协议
    • TSDB_SML_JSON_PROTOCOL: OpenTSDB Json 协议格式

    时间戳分辨率的定义，定义在 taos.h 文件中，具体内容如下：

    • TSDB_SML_TIMESTAMP_NOT_CONFIGURED = 0,
    • TSDB_SML_TIMESTAMP_HOURS,
    • TSDB_SML_TIMESTAMP_MINUTES,
    • TSDB_SML_TIMESTAMP_SECONDS,
    • TSDB_SML_TIMESTAMP_MILLI_SECONDS,
    • TSDB_SML_TIMESTAMP_MICRO_SECONDS,
    • TSDB_SML_TIMESTAMP_NANO_SECONDS

    需要注意的是，时间戳分辨率参数只在协议类型为 SML_LINE_PROTOCOL 的时候生效。 对于 OpenTSDB 的文本协议，时间戳的解析遵循其官方解析规则 — 按照时间戳包含的字符的数量来确认时间精度。

    支持版本 该功能接口从 2.3.0.0 版本开始支持。

订阅和消费 API

订阅 API 目前支持订阅一张或多张表，并通过定期轮询的方式不断获取写入表中的最新数据。

  • TAOS_SUB *taos_subscribe(TAOS* taos, int restart, const char* topic, const char *sql, TAOS_SUBSCRIBE_CALLBACK fp, void *param, int interval)

    该函数负责启动订阅服务，成功时返回订阅对象，失败时返回 NULL，其参数为：

    • taos：已经建立好的数据库连接
    • restart：如果订阅已经存在，是重新开始，还是继续之前的订阅
    • topic：订阅的主题（即名称），此参数是订阅的唯一标识
    • sql：订阅的查询语句，此语句只能是 select 语句，只应查询原始数据，只能按时间正序查询数据
    • fp：收到查询结果时的回调函数（稍后介绍函数原型），只在异步调用时使用，同步调用时此参数应该传 NULL
    • param：调用回调函数时的附加参数，系统 API 将其原样传递到回调函数，不进行任何处理
    • interval：轮询周期，单位为毫秒。异步调用时，将根据此参数周期性的调用回调函数，为避免对系统性能造成影响，不建议将此参数设置的过小；同步调用时，如两次调用 taos_consume() 的间隔小于此周期，API 将会阻塞，直到时间间隔超过此周期。

  • typedef void (*TAOS_SUBSCRIBE_CALLBACK)(TAOS_SUB* tsub, TAOS_RES *res, void* param, int code)

    异步模式下，回调函数的原型，其参数为：

    • tsub：订阅对象
    • res：查询结果集，注意结果集中可能没有记录
    • param：调用 taos_subscribe() 时客户程序提供的附加参数
    • code：错误码
    C/C++ - 图5note

    在这个回调函数里不可以做耗时过长的处理，尤其是对于返回的结果集中数据较多的情况，否则有可能导致客户端阻塞等异常状态。如果必须进行复杂计算，则建议在另外的线程中进行处理。

  • TAOS_RES *taos_consume(TAOS_SUB *tsub)

    同步模式下，该函数用来获取订阅的结果。 用户应用程序将其置于一个循环之中。 如两次调用 taos_consume() 的间隔小于订阅的轮询周期，API 将会阻塞，直到时间间隔超过此周期。如果数据库有新记录到达，该 API 将返回该最新的记录，否则返回一个没有记录的空结果集。 如果返回值为 NULL，说明系统出错。 异步模式下，用户程序不应调用此 API。

    C/C++ - 图6note

    在调用 taos_consume() 之后，用户应用应确保尽快调用 taos_fetch_row() 或 taos_fetch_block() 来处理订阅结果，否则服务端会持续缓存查询结果数据等待客户端读取，极端情况下会导致服务端内存消耗殆尽，影响服务稳定性。

  • void taos_unsubscribe(TAOS_SUB *tsub, int keepProgress)

    取消订阅。 如参数 keepProgress 不为 0，API 会保留订阅的进度信息，后续调用 taos_subscribe() 时可以基于此进度继续；否则将删除进度信息，后续只能重新开始读取数据。