Merge branch 'docs-cloud' into docs/sangshuduo/cloud-doc-restapi

docs/en/01-index.md

 ---
 title: TDengine Cloud Service Documentation
-sidebar_label: Documentation Home
+sidebar_label: Home
 slug: /
 ---
+TDengine Cloud, is the fast, elastic, serverless and cost effective time-series data processing service based on the popular open source time-series database, TDengine. With TDengine Cloud, IoT and Big Data developers now have access, on various Cloud providers, to the same robustness, speed and scalability for which TDengine is known. TDengine Cloud delivers a comprehensive, serverless time-series platform that allows customers to focus on solving business needs not only by freeing them from operations and maintenance, but also by providing features such as caching, stream processing and PubSub in one integrated platform thus reducing complexity. At the same time, customers can rest assured that ubiquitous third-party tools such as Prometheus, Telegraf, Grafana and MQTT brokers are supported. Naturally, TDengine Cloud supports connectors in Python, Java, Go, Rust and Node.js thus allowing developers to develop in their language of choice. With SQL support as well as support for schema-less ingestion, TDengine Cloud is adaptable to the needs of all developers. TDengine Cloud also provides additional functions specifically for time series analysis, which makes data analysis and visualization a lot simpler.
+
+This is the documentation structure for TDengine Cloud.
+
+1. The [Introduction](./intro) provides an overview of the features, capabilities and competitive advantages of TDengine Cloud.
+
+2. In [Get Started](./get-started) you will see a tutorial that introduces some of the novel concepts in TDengine, its architecture and also some information on the sample database that you can use to get an idea of the sheer speed of TDengine Cloud. Note that the sample database has 100 million rows to reflect a real world database. Please read the concepts section carefully since TDengine uses these concepts as the foundation to create extremely high-performing IoT and Big Data time-series applications.
+
+3. The [Developer Guide](./develop) is a must read if you are developing IoT or Big Data applications for time series data. In this section we introduce the database connection, data modeling, data ingestion, query, stream processing, cache, data subscription, user-defined functions (coming soon), and other functionality in detail. Sample code is provided for a variety of programming languages. In most cases, you can just copy and paste the sample code, make a few changes to accommodate your application, and it will work.
+
+4. In the [Data In](./data-in) section we show you a number of ways for you to get your data into TDengine.
+
+5. TDengine Cloud believes in giving you extremely easy access to your data and in the [Data Out](./data-out) section we show you a number of ways to get data out of TDengine and into your analysis and visualization applications.
+
+6. The [Visualization](./visual) section shows you how you can visualize the data that you store in TDengine, as well as how you can visualize and monitor the status of your TDengine Cloud instance(s) and databases.
+
+7. The [TDengine SQL](./taos-sql) section provides comprehensive information about both standard SQL as well as TDengine's extensions for easy time series analysis.
+
+8. In [Connector](./connector), you can choose between Python, Java, Go, Rust and Node.js, to easily connect to TDengine to ingest and query data in your preferred development language.
+
+9. The [Tools](./tools) section introduces the Taos CLI which gives you shell access to easily perform ad hoc queries on your instances and databases. Additionally, taosBenchmark is introduced. It is a tool that can help you generate large amounts of data very easily with simple configurations and test the performance of TDengine Cloud.
+
+10. Finally, in the [FAQ](./faq) section, we try to preemptively answer questions that we anticipate. Of course, we will continue to add to this section all the time.
+
+We are very excited that you have chosen TDengine Cloud to be part of your time series platform and look forward to hearing your feedback and ways in which we can improve and be a small part of your success.

docs/en/02-intro.md

 ---
 sidebar_label: Introduction
-title: TDengine Cloud Service
+title: Introduction to TDengine Cloud Service
 ---
+
+TDengine Cloud, is the fast, elastic, serverless and cost effective time-series data processing service based on the popular open source time-series database, TDengine. With TDengine Cloud you get the highly optimized and purpose-built for IoT time-series platform, for which TDengine is known. 
+
+This section introduces the major features, competitive advantages, typical use-cases and benchmarks to help you get a high level overview of TDengine.
+
+## Major Features
+
+The major features are listed below:
+
+1. While TDengine supports [using SQL to insert](/develop/insert-data/sql-writing), it also supports [Schemaless writing](/reference/schemaless/) just like NoSQL databases. TDengine also supports standard protocols like [InfluxDB LINE](/develop/insert-data/influxdb-line)，[OpenTSDB Telnet](/develop/insert-data/opentsdb-telnet), [OpenTSDB JSON ](/develop/insert-data/opentsdb-json) among others.
+2. TDengine supports seamless integration with third-party data collection agents like [Telegraf](/third-party/telegraf)，[Prometheus](/third-party/prometheus)，[StatsD](/third-party/statsd)，[collectd](/third-party/collectd)，[icinga2](/third-party/icinga2), [TCollector](/third-party/tcollector), [EMQX](/third-party/emq-broker), [HiveMQ](/third-party/hive-mq-broker). These agents can write data into TDengine with simple configuration and without a single line of code. 
+3. Support for [all kinds of queries](/develop/query-data), including aggregation, nested query, downsampling, interpolation and others.
+4. Support for [user defined functions](/develop/udf).
+5. Support for [caching](/develop/cache). TDengine always saves the last data point in cache, so Redis is not needed in some scenarios.
+6. Support for [stream processing](../taos-sql).
+7. Support for [data subscription](../taos-sql) with the capability to specify filter conditions.
+8. High availability is supported by replication including multi-cloud replication. 
+9. Provides an interactive [command-line interface](/reference/taos-shell) for management, maintenance and ad-hoc queries.
+10. Provides many ways to [get data in](../data-in) and [get data out](../data-out) data.
+11. Provides a Dashboard to monitor your running instances of TDengine.
+12. Provides [connectors](../connector/) for [Java](../connector/java), [Python](../connector/python), [Go](../connector/go), [Rust](../connector/rust), and [Node.js](../connector/node).
+13. Provides a [REST API](/reference/rest-api/).
+14. Supports seamless integration with [Grafana](../visual/grafana) for visualization.
+15. Supports seamless integration with Google Data Studio.
+
+For more details on features, please read through the entire documentation. 
+
+## Competitive Advantages
+
+By making full use of [characteristics of time series data](https://tdengine.com/tsdb/characteristics-of-time-series-data/), TDengine Cloud differentiates itself from other time series platforms, with the following advantages.
+
+- **[High-Performance](https://tdengine.com/tdengine/high-performance-time-series-database/)**: TDengine Cloud is a fast, elastic, serverless purpose built platform for IoT time-series data. It is the only time-series platform to solve the high cardinality issue to support billions of data collection points while outperforming other time-series platforms for data ingestion, querying and data compression.
+
+- **[Simplified Solution](https://tdengine.com/tdengine/simplified-time-series-data-solution/)**: Through built-in caching, stream processing and data subscription features, TDengine provides a simplified solution for time-series data processing. It reduces system design complexity and operation costs significantly.
+
+- **[Cloud Native](https://tdengine.com/tdengine/cloud-native-time-series-database/)**: Through native distributed design, sharding and partitioning, separation of compute and storage, RAFT, support for kubernetes deployment and full observability, TDengine is a cloud native Time-Series Database and can be deployed on public, private or hybrid clouds. It is Enterprise ready with backup, multi-cloud replication, VPC peering and IP whitelisting.
+
+- **[Ease of Use](https://tdengine.com/tdengine/easy-time-series-data-platform/)**: For administrators, TDengine Cloud provides worry-free operations with a fully managed cloud native solution. For developers, it provides a simple interface, simplified solution and seamless integration with third party tools. For data users, it provides SQL support with powerful time series extensions built for data analytics.
+
+- **[Easy Data Analytics](https://tdengine.com/tdengine/time-series-data-analytics-made-easy/)**: Through super tables, storage and compute separation, data partitioning by time interval, pre-computation and other means, TDengine makes it easy to explore, format, and get access to data in a highly efficient way.

docs/en/04-get-started.md

-# Get Started
\ No newline at end of file
+---
+sidebar_label: Get Started
+title: Get Started
+description: A quick guide for how to access TDengine cloud service
+---
+
+It's very convenient to access TDengine cloud service, just open your browser, connect to [TDengine Cloud Service Portal](https://cloud.tdengine.com), create an account with a valid email address, activate your account, then you will get a free TDengine cloud service. Enjoy!
\ No newline at end of file

docs/en/05-develop/04-stream.md

+---
+sidebar_label: Stream Processing
+description: "The TDengine stream processing engine combines data inserts, preprocessing, analytics, real-time computation, and alerting into a single component."
+title: Stream Processing
+---
+
+Raw time-series data is often cleaned and preprocessed before being permanently stored in a database. In a traditional time-series solution, this generally requires the deployment of stream processing systems such as Kafka or Flink. However, the complexity of such systems increases the cost of development and maintenance.
+
+With the stream processing engine built into TDengine, you can process incoming data streams in real time and define stream transformations in SQL. Incoming data is automatically processed, and the results are pushed to specified tables based on triggering rules that you define. This is a lightweight alternative to complex processing engines that returns computation results in milliseconds even in high throughput scenarios.
+
+The stream processing engine includes data filtering, scalar function computation (including user-defined functions), and window aggregation, with support for sliding windows, session windows, and event windows. Stream processing can write data to supertables from other supertables, standard tables, or subtables. When you create a stream, the target supertable is automatically created. New data is then processed and written to that supertable according to the rules defined for the stream. You can use PARTITION BY statements to partition the data by table name or tag. Separate partitions are then written to different subtables within the target supertable.
+
+TDengine stream processing supports the aggregation of supertables that are deployed across multiple vnodes. It can also handle out-of-order writes and includes a watermark mechanism that determines the extent to which out-of-order data is accepted by the system. You can configure whether to drop or reprocess out-of-order data through the **ignore expired** parameter.
+
+For more information, see [Stream Processing](../../taos-sql/stream).
+
+
+## Create a Stream
+
+```sql
+CREATE STREAM [IF NOT EXISTS] stream_name [stream_options] INTO stb_name AS subquery
+stream_options: {
+ TRIGGER    [AT_ONCE | WINDOW_CLOSE | MAX_DELAY time]
+ WATERMARK   time
+ IGNORE EXPIRED [0 | 1]
+}
+```
+
+For more information, see [Stream Processing](../../taos-sql/stream).
+
+## Usage Scenario 1
+
+It is common that smart electrical meter systems for businesses generate millions of data points that are widely dispersed and not ordered. The time required to clean and convert this data makes efficient, real-time processing impossible for traditional solutions. This scenario shows how you can configure TDengine stream processing to drop data points over 220 V, find the maximum voltage for 5 second windows, and output this data to a table.
+
+### Create a Database for Raw Data
+
+A database including one supertable and four subtables is created as follows:
+
+```sql
+DROP DATABASE IF EXISTS power;
+CREATE DATABASE power;
+USE power;
+
+CREATE STABLE meters (ts timestamp, current float, voltage int, phase float) TAGS (location binary(64), groupId int);
+
+CREATE TABLE d1001 USING meters TAGS ("California.SanFrancisco", 2);
+CREATE TABLE d1002 USING meters TAGS ("California.SanFrancisco", 3);
+CREATE TABLE d1003 USING meters TAGS ("California.LosAngeles", 2);
+CREATE TABLE d1004 USING meters TAGS ("California.LosAngeles", 3);
+```
+
+### Create a Stream
+
+```sql
+create stream current_stream into current_stream_output_stb as select _wstart as start, _wend as end, max(current) as max_current from meters where voltage <= 220 interval (5s);
+```
+
+### Write Data
+```sql
+insert into d1001 values("2018-10-03 14:38:05.000", 10.30000, 219, 0.31000);
+insert into d1001 values("2018-10-03 14:38:15.000", 12.60000, 218, 0.33000);
+insert into d1001 values("2018-10-03 14:38:16.800", 12.30000, 221, 0.31000);
+insert into d1002 values("2018-10-03 14:38:16.650", 10.30000, 218, 0.25000);
+insert into d1003 values("2018-10-03 14:38:05.500", 11.80000, 221, 0.28000);
+insert into d1003 values("2018-10-03 14:38:16.600", 13.40000, 223, 0.29000);
+insert into d1004 values("2018-10-03 14:38:05.000", 10.80000, 223, 0.29000);
+insert into d1004 values("2018-10-03 14:38:06.500", 11.50000, 221, 0.35000);
+```
+
+### Query the Results
+
+```sql
+taos> select start, end, max_current from current_stream_output_stb;
+          start          |           end           |     max_current      |
+===========================================================================
+ 2018-10-03 14:38:05.000 | 2018-10-03 14:38:10.000 |             10.30000 |
+ 2018-10-03 14:38:15.000 | 2018-10-03 14:38:20.000 |             12.60000 |
+Query OK, 2 rows in database (0.018762s)
+```
+
+## Usage Scenario 2
+
+In this scenario, the active power and reactive power are determined from the data gathered in the previous scenario. The location and name of each meter are concatenated with a period (.) between them, and the data set is partitioned by meter name and written to a new database.
+
+### Create a Database for Raw Data
+
+The procedure from the previous scenario is used to create the database.
+
+### Create a Stream
+
+```sql
+create stream power_stream into power_stream_output_stb as select ts, concat_ws(".", location, tbname) as meter_location, current*voltage*cos(phase) as active_power, current*voltage*sin(phase) as reactive_power from meters partition by tbname;
+```
+
+### Write data
+
+The procedure from the previous scenario is used to write the data.
+
+### Query the Results
+```sql
+taos> select ts, meter_location, active_power, reactive_power from power_stream_output_stb;
+           ts            |         meter_location         |       active_power        |      reactive_power       |
+===================================================================================================================
+ 2018-10-03 14:38:05.000 | California.LosAngeles.d1004    |            2307.834596289 |             688.687331847 |
+ 2018-10-03 14:38:06.500 | California.LosAngeles.d1004    |            2387.415754896 |             871.474763418 |
+ 2018-10-03 14:38:05.500 | California.LosAngeles.d1003    |            2506.240411679 |             720.680274962 |
+ 2018-10-03 14:38:16.600 | California.LosAngeles.d1003    |            2863.424274422 |             854.482390839 |
+ 2018-10-03 14:38:05.000 | California.SanFrancisco.d1001  |            2148.178871730 |             688.120784090 |
+ 2018-10-03 14:38:15.000 | California.SanFrancisco.d1001  |            2598.589176205 |             890.081451418 |
+ 2018-10-03 14:38:16.800 | California.SanFrancisco.d1001  |            2588.728381186 |             829.240910475 |
+ 2018-10-03 14:38:16.650 | California.SanFrancisco.d1002  |            2175.595991997 |             555.520860397 |
+Query OK, 8 rows in database (0.014753s)
+```

docs/en/06-replication/index.md

+---
+sidebar_label: Data Replication
+title: Data Replication
+description: Briefly introduce how to replicate data among TDengine cloud services
+---
+
+TDengine provides full support for data replication. You can replicate data from TDengine cloud service to local TDengine, from local TDengine to TDengine cloud service, or from one cloud service to another one and it doesn't matter which cloud or region the two services reside in.
\ No newline at end of file

docs/en/08-data-in/06-taosx.md

-# taosX
\ No newline at end of file

docs/en/09-data-out/05-taosx.md

-# taosX
\ No newline at end of file

docs/en/09-data-out/_sub_c.mdx

+```c
+{{#include docs/examples/c/tmq_example.c}}
+```

docs/en/09-data-out/_sub_cs.mdx

+```csharp
+{{#include docs/examples/csharp/SubscribeDemo.cs}}
+```
\ No newline at end of file

docs/en/09-data-out/_sub_go.mdx

+```go
+{{#include docs/examples/go/sub/main.go}}
+```
\ No newline at end of file

docs/en/09-data-out/_sub_java.mdx

+```java
+{{#include docs/examples/java/src/main/java/com/taos/example/SubscribeDemo.java}}
+{{#include docs/examples/java/src/main/java/com/taos/example/MetersDeserializer.java}}
+{{#include docs/examples/java/src/main/java/com/taos/example/Meters.java}}
+```
+```java
+{{#include docs/examples/java/src/main/java/com/taos/example/MetersDeserializer.java}}
+```
+```java
+{{#include docs/examples/java/src/main/java/com/taos/example/Meters.java}}
+```
\ No newline at end of file

docs/en/09-data-out/_sub_node.mdx

+```js
+{{#include docs/examples/node/nativeexample/subscribe_demo.js}}
+```
\ No newline at end of file

docs/en/09-data-out/_sub_python.mdx

+```py
+{{#include docs/examples/python/tmq_example.py}}
+```

docs/en/09-data-out/_sub_rust.mdx

+```rust
+{{#include docs/examples/rust/nativeexample/examples/subscribe_demo.rs}}
+```

docs/examples/R/connect_native.r

+if (! "RJDBC" %in% installed.packages()[, "Package"]) {
+  install.packages('RJDBC', repos='http://cran.us.r-project.org')
+}
+
+# ANCHOR: demo
+library("DBI")
+library("rJava")
+library("RJDBC")
+
+args<- commandArgs(trailingOnly = TRUE)
+driver_path = args[1] # path to jdbc-driver for example: "/root/taos-jdbcdriver-3.0.0-dist.jar"
+driver = JDBC("com.taosdata.jdbc.TSDBDriver", driver_path)
+conn = dbConnect(driver, "jdbc:TAOS://127.0.0.1:6030/?user=root&password=taosdata")
+dbGetQuery(conn, "SELECT server_version()")
+dbDisconnect(conn)
+# ANCHOR_END: demo

docs/examples/R/connect_rest.r

+if (! "RJDBC" %in% installed.packages()[, "Package"]) {
+  install.packages('RJDBC', repos='http://cran.us.r-project.org')
+}
+
+library("DBI")
+library("rJava")
+library("RJDBC")
+driver_path = "/home/debug/build/lib/taos-jdbcdriver-2.0.38-dist.jar"
+driver = JDBC("com.taosdata.jdbc.rs.RestfulDriver", driver_path)
+conn = dbConnect(driver, "jdbc:TAOS-RS://localhost:6041?user=root&password=taosdata")
+dbGetQuery(conn, "SELECT server_version()")
+dbDisconnect(conn)
\ No newline at end of file

docs/examples/c/.gitignore

+*
+!*.c
+!.gitignore

docs/examples/c/async_query_example.c

+// compile with:
+// gcc -o async_query_example async_query_example.c -ltaos
+
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/time.h>
+#include <taos.h>
+
+typedef int16_t VarDataLenT;
+
+#define TSDB_NCHAR_SIZE sizeof(int32_t)
+#define VARSTR_HEADER_SIZE sizeof(VarDataLenT)
+
+#define GET_FLOAT_VAL(x) (*(float *)(x))
+#define GET_DOUBLE_VAL(x) (*(double *)(x))
+
+#define varDataLen(v) ((VarDataLenT *)(v))[0]
+
+int printRow(char *str, TAOS_ROW row, TAOS_FIELD *fields, int numFields) {
+  int  len = 0;
+  char split = ' ';
+
+  for (int i = 0; i < numFields; ++i) {
+    if (i > 0) {
+      str[len++] = split;
+    }
+
+    if (row[i] == NULL) {
+      len += sprintf(str + len, "%s", "NULL");
+      continue;
+    }
+
+    switch (fields[i].type) {
+      case TSDB_DATA_TYPE_TINYINT:
+        len += sprintf(str + len, "%d", *((int8_t *)row[i]));
+        break;
+
+      case TSDB_DATA_TYPE_UTINYINT:
+        len += sprintf(str + len, "%u", *((uint8_t *)row[i]));
+        break;
+
+      case TSDB_DATA_TYPE_SMALLINT:
+        len += sprintf(str + len, "%d", *((int16_t *)row[i]));
+        break;
+
+      case TSDB_DATA_TYPE_USMALLINT:
+        len += sprintf(str + len, "%u", *((uint16_t *)row[i]));
+        break;
+
+      case TSDB_DATA_TYPE_INT:
+        len += sprintf(str + len, "%d", *((int32_t *)row[i]));
+        break;
+
+      case TSDB_DATA_TYPE_UINT:
+        len += sprintf(str + len, "%u", *((uint32_t *)row[i]));
+        break;
+
+      case TSDB_DATA_TYPE_BIGINT:
+        len += sprintf(str + len, "%" PRId64, *((int64_t *)row[i]));
+        break;
+
+      case TSDB_DATA_TYPE_UBIGINT:
+        len += sprintf(str + len, "%" PRIu64, *((uint64_t *)row[i]));
+        break;
+
+      case TSDB_DATA_TYPE_FLOAT: {
+        float fv = 0;
+        fv = GET_FLOAT_VAL(row[i]);
+        len += sprintf(str + len, "%f", fv);
+      } break;
+
+      case TSDB_DATA_TYPE_DOUBLE: {
+        double dv = 0;
+        dv = GET_DOUBLE_VAL(row[i]);
+        len += sprintf(str + len, "%lf", dv);
+      } break;
+
+      case TSDB_DATA_TYPE_BINARY:
+      case TSDB_DATA_TYPE_NCHAR: {
+        int32_t charLen = varDataLen((char *)row[i] - VARSTR_HEADER_SIZE);
+        memcpy(str + len, row[i], charLen);
+        len += charLen;
+      } break;
+
+      case TSDB_DATA_TYPE_TIMESTAMP:
+        len += sprintf(str + len, "%" PRId64, *((int64_t *)row[i]));
+        break;
+
+      case TSDB_DATA_TYPE_BOOL:
+        len += sprintf(str + len, "%d", *((int8_t *)row[i]));
+      default:
+        break;
+    }
+  }
+
+  return len;
+}
+
+void printHeader(TAOS_RES *res) {
+  int         numFields = taos_num_fields(res);
+  TAOS_FIELD *fields = taos_fetch_fields(res);
+  char        header[256] = {0};
+  int         len = 0;
+  for (int i = 0; i < numFields; ++i) {
+    len += sprintf(header + len, "%s ", fields[i].name);
+  }
+  puts(header);
+}
+
+// ANCHOR: demo
+
+/**
+ * @brief call back function of taos_fetch_row_a
+ *
+ * @param param : the third parameter you passed to taos_fetch_row_a
+ * @param res : pointer of TAOS_RES
+ * @param numOfRow : number of rows fetched in this batch. will be 0 if there is no more data.
+ * @return void*
+ */
+void *fetch_row_callback(void *param, TAOS_RES *res, int numOfRow) {
+  printf("numOfRow = %d \n", numOfRow);
+  int         numFields = taos_num_fields(res);
+  TAOS_FIELD *fields = taos_fetch_fields(res);
+  TAOS       *_taos = (TAOS *)param;
+  if (numOfRow > 0) {
+    for (int i = 0; i < numOfRow; ++i) {
+      TAOS_ROW row = taos_fetch_row(res);
+      char     temp[256] = {0};
+      printRow(temp, row, fields, numFields);
+      puts(temp);
+    }
+    taos_fetch_rows_a(res, fetch_row_callback, _taos);
+  } else {
+    printf("no more data, close the connection.\n");
+    taos_free_result(res);
+    taos_close(_taos);
+    taos_cleanup();
+  }
+}
+
+/**
+ * @brief callback function of taos_query_a
+ *
+ * @param param: the fourth parameter you passed to taos_query_a
+ * @param res : the result set
+ * @param code : status code
+ * @return void*
+ */
+void *select_callback(void *param, TAOS_RES *res, int code) {
+  printf("query callback ...\n");
+  TAOS *_taos = (TAOS *)param;
+  if (code == 0 && res) {
+    printHeader(res);
+    taos_fetch_rows_a(res, fetch_row_callback, _taos);
+  } else {
+    printf("failed to execute taos_query. error: %s\n", taos_errstr(res));
+    taos_free_result(res);
+    taos_close(_taos);
+    taos_cleanup();
+    exit(EXIT_FAILURE);
+  }
+}
+
+int main() {
+  TAOS *taos = taos_connect("localhost", "root", "taosdata", "power", 6030);
+  if (taos == NULL) {
+    puts("failed to connect to server");
+    exit(EXIT_FAILURE);
+  }
+  // param one is the connection returned by taos_connect.
+  // param two is the SQL to execute.
+  // param three is the callback function.
+  // param four can be any pointer. It will be passed to your callback function as the first parameter. we use taos
+  // here, because we want to close it after getting data.
+  taos_query_a(taos, "SELECT * FROM meters", select_callback, taos);
+  sleep(1);
+}
+
+// output:
+// query callback ...
+// ts current voltage phase location groupid
+// numOfRow = 8
+// 1538548685500 11.800000 221 0.280000 california.losangeles 2
+// 1538548696600 13.400000 223 0.290000 california.losangeles 2
+// 1538548685000 10.800000 223 0.290000 california.losangeles 3
+// 1538548686500 11.500000 221 0.350000 california.losangeles 3
+// 1538548685000 10.300000 219 0.310000 california.sanfrancisco 2
+// 1538548695000 12.600000 218 0.330000 california.sanfrancisco 2
+// 1538548696800 12.300000 221 0.310000 california.sanfrancisco 2
+// 1538548696650 10.300000 218 0.250000 california.sanfrancisco 3
+// numOfRow = 0
+// no more data, close the connection.
+// ANCHOR_END: demo
\ No newline at end of file

docs/examples/c/connect_example.c

+// compile with
+// gcc connect_example.c -o connect_example -ltaos
+#include <stdio.h>
+#include <stdlib.h>
+#include "taos.h"
+
+int main() {
+  const char *host = "localhost";
+  const char *user = "root";
+  const char *passwd = "taosdata";
+  // if don't want to connect to a default db, set it to NULL or ""
+  const char *db = NULL;
+  uint16_t    port = 0;  // 0 means use the default port
+  TAOS       *taos = taos_connect(host, user, passwd, db, port);
+  if (taos == NULL) {
+    int   errno = taos_errno(NULL);
+    char *msg = taos_errstr(NULL);
+    printf("%d, %s\n", errno, msg);
+  } else {
+    printf("connected\n");
+    taos_close(taos);
+  }
+  taos_cleanup();
+}

docs/examples/c/error_handle_example.c

+// compile with
+// gcc error_handle_example.c -o error_handle_example -ltaos
+#include <stdio.h>
+#include <stdlib.h>
+#include "taos.h"
+
+int main() {
+  const char *host = "localhost";
+  const char *user = "root";
+  const char *passwd = "taosdata";
+  // if don't want to connect to a default db, set it to NULL or ""
+  const char *db = "notexist";
+  uint16_t    port = 0;  // 0 means use the default port
+  TAOS       *taos = taos_connect(host, user, passwd, db, port);
+  if (taos == NULL) {
+    int errno = taos_errno(NULL);
+    char *msg = taos_errstr(NULL);
+    printf("%d, %s\n", errno, msg);
+  } else {
+    printf("connected\n");
+    taos_close(taos);
+  }
+  taos_cleanup();
+}

docs/examples/c/insert_example.c

+// compile with
+// gcc -o insert_example insert_example.c -ltaos
+#include <stdio.h>
+#include <stdlib.h>
+#include "taos.h"
+
+
+/**
+ * @brief execute sql and print affected rows.
+ * 
+ * @param taos 
+ * @param sql 
+ */
+void executeSQL(TAOS *taos, const char *sql) {
+  TAOS_RES *res = taos_query(taos, sql);
+  int       code = taos_errno(res);
+  if (code != 0) {
+    printf("Error code: %d; Message: %s\n", code, taos_errstr(res));
+    taos_free_result(res);
+    taos_close(taos);
+    exit(EXIT_FAILURE);
+  }
+  int affectedRows = taos_affected_rows(res);
+  printf("affected rows %d\n", affectedRows);
+  taos_free_result(res);
+}
+
+
+
+int main() {
+   TAOS *taos = taos_connect("localhost", "root", "taosdata", NULL, 6030);
+  if (taos == NULL) {
+    printf("failed to connect to server\n");
+    exit(EXIT_FAILURE);
+  }
+  executeSQL(taos, "CREATE DATABASE power");
+  executeSQL(taos, "USE power");
+  executeSQL(taos, "CREATE STABLE meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS (location BINARY(64), groupId INT)");
+  executeSQL(taos, "INSERT INTO d1001 USING meters TAGS(California.SanFrancisco, 2) VALUES ('2018-10-03 14:38:05.000', 10.30000, 219, 0.31000) ('2018-10-03 14:38:15.000', 12.60000, 218, 0.33000) ('2018-10-03 14:38:16.800', 12.30000, 221, 0.31000)"
+                "d1002 USING meters TAGS(California.SanFrancisco, 3) VALUES ('2018-10-03 14:38:16.650', 10.30000, 218, 0.25000)"
+                "d1003 USING meters TAGS(California.LosAngeles, 2) VALUES ('2018-10-03 14:38:05.500', 11.80000, 221, 0.28000) ('2018-10-03 14:38:16.600', 13.40000, 223, 0.29000)"
+                "d1004 USING meters TAGS(California.LosAngeles, 3) VALUES ('2018-10-03 14:38:05.000', 10.80000, 223, 0.29000) ('2018-10-03 14:38:06.500', 11.50000, 221, 0.35000)");
+  taos_close(taos);
+  taos_cleanup();
+}
+
+// output:
+// affected rows 0
+// affected rows 0
+// affected rows 0
+// affected rows 8
\ No newline at end of file

docs/examples/c/json_protocol_example.c

+// compile with
+// gcc -o json_protocol_example json_protocol_example.c -ltaos
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "taos.h"
+
+void executeSQL(TAOS *taos, const char *sql) {
+  TAOS_RES *res = taos_query(taos, sql);
+  int       code = taos_errno(res);
+  if (code != 0) {
+    printf("%s\n", taos_errstr(res));
+    taos_free_result(res);
+    taos_close(taos);
+    exit(EXIT_FAILURE);
+  }
+  taos_free_result(res);
+}
+
+// ANCHOR: main
+int main() {
+  TAOS *taos = taos_connect("localhost", "root", "taosdata", "", 6030);
+  if (taos == NULL) {
+    printf("failed to connect to server\n");
+    exit(EXIT_FAILURE);
+  }
+  executeSQL(taos, "DROP DATABASE IF EXISTS test");
+  executeSQL(taos, "CREATE DATABASE test");
+  executeSQL(taos, "USE test");
+  char *line =
+      "[{\"metric\": \"meters.current\", \"timestamp\": 1648432611249, \"value\": 10.3, \"tags\": {\"location\": "
+      "\"California.SanFrancisco\", \"groupid\": 2}},{\"metric\": \"meters.voltage\", \"timestamp\": 1648432611249, "
+      "\"value\": 219, \"tags\": {\"location\": \"California.LosAngeles\", \"groupid\": 1}},{\"metric\": \"meters.current\", "
+      "\"timestamp\": 1648432611250, \"value\": 12.6, \"tags\": {\"location\": \"California.SanFrancisco\", \"groupid\": "
+      "2}},{\"metric\": \"meters.voltage\", \"timestamp\": 1648432611250, \"value\": 221, \"tags\": {\"location\": "
+      "\"California.LosAngeles\", \"groupid\": 1}}]";
+
+  char     *lines[] = {line};
+  TAOS_RES *res = taos_schemaless_insert(taos, lines, 1, TSDB_SML_JSON_PROTOCOL, TSDB_SML_TIMESTAMP_NOT_CONFIGURED);
+  if (taos_errno(res) != 0) {
+    printf("failed to insert schema-less data, reason: %s\n", taos_errstr(res));
+  } else {
+    int affectedRow = taos_affected_rows(res);
+    printf("successfully inserted %d rows\n", affectedRow);
+  }
+  taos_free_result(res);
+  taos_close(taos);
+  taos_cleanup();
+}
+// output:
+// successfully inserted 4 rows
+// ANCHOR_END: main

docs/examples/c/line_example.c

+// compile with
+// gcc -o line_example line_example.c -ltaos
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "taos.h"
+
+void executeSQL(TAOS *taos, const char *sql) {
+  TAOS_RES *res = taos_query(taos, sql);
+  int       code = taos_errno(res);
+  if (code != 0) {
+    printf("%s\n", taos_errstr(res));
+    taos_free_result(res);
+    taos_close(taos);
+    exit(EXIT_FAILURE);
+  }
+  taos_free_result(res);
+}
+
+// ANCHOR: main
+int main() {
+  TAOS *taos = taos_connect("localhost", "root", "taosdata", "", 0);
+  if (taos == NULL) {
+    printf("failed to connect to server\n");
+    exit(EXIT_FAILURE);
+  }
+  executeSQL(taos, "DROP DATABASE IF EXISTS test");
+  executeSQL(taos, "CREATE DATABASE test");
+  executeSQL(taos, "USE test");
+  char     *lines[] = {"meters,location=California.LosAngeles,groupid=2 current=11.8,voltage=221,phase=0.28 1648432611249",
+                   "meters,location=California.LosAngeles,groupid=2 current=13.4,voltage=223,phase=0.29 1648432611250",
+                   "meters,location=California.LosAngeles,groupid=3 current=10.8,voltage=223,phase=0.29 1648432611249",
+                   "meters,location=California.LosAngeles,groupid=3 current=11.3,voltage=221,phase=0.35 1648432611250"};
+  TAOS_RES *res = taos_schemaless_insert(taos, lines, 4, TSDB_SML_LINE_PROTOCOL, TSDB_SML_TIMESTAMP_MILLI_SECONDS);
+  if (taos_errno(res) != 0) {
+    printf("failed to insert schema-less data, reason: %s\n", taos_errstr(res));
+  } else {
+    int affectedRows = taos_affected_rows(res);
+    printf("successfully inserted %d rows\n", affectedRows);
+  }
+  taos_free_result(res);
+  taos_close(taos);
+  taos_cleanup();
+}
+// output:
+// successfully inserted 4 rows
+// ANCHOR_END: main
\ No newline at end of file

docs/examples/c/multi_bind_example.c

+// compile with
+// gcc -o multi_bind_example multi_bind_example.c -ltaos
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "taos.h"
+
+/**
+ * @brief execute sql only and ignore result set
+ *
+ * @param taos
+ * @param sql
+ */
+void executeSQL(TAOS *taos, const char *sql) {
+  TAOS_RES *res = taos_query(taos, sql);
+  int       code = taos_errno(res);
+  if (code != 0) {
+    printf("%s\n", taos_errstr(res));
+    taos_free_result(res);
+    taos_close(taos);
+    exit(EXIT_FAILURE);
+  }
+  taos_free_result(res);
+}
+
+/**
+ * @brief exit program when error occur.
+ *
+ * @param stmt
+ * @param code
+ * @param msg
+ */
+void checkErrorCode(TAOS_STMT *stmt, int code, const char *msg) {
+  if (code != 0) {
+    printf("%s. error: %s\n", msg, taos_stmt_errstr(stmt));
+    taos_stmt_close(stmt);
+    exit(EXIT_FAILURE);
+  }
+}
+
+/**
+ * @brief insert data using stmt API
+ *
+ * @param taos
+ */
+void insertData(TAOS *taos) {
+  // init
+  TAOS_STMT *stmt = taos_stmt_init(taos);
+  // prepare
+  const char *sql = "INSERT INTO ? USING meters TAGS(?, ?) values(?, ?, ?, ?)";
+  int         code = taos_stmt_prepare(stmt, sql, 0);
+  checkErrorCode(stmt, code, "failed to execute taos_stmt_prepare");
+  // bind table name and tags
+  TAOS_BIND tags[2];
+  char     *location = "California.SanFrancisco";
+  int       groupId = 2;
+  tags[0].buffer_type = TSDB_DATA_TYPE_BINARY;
+  tags[0].buffer_length = strlen(location);
+  tags[0].length = &tags[0].buffer_length;
+  tags[0].buffer = location;
+  tags[0].is_null = NULL;
+
+  tags[1].buffer_type = TSDB_DATA_TYPE_INT;
+  tags[1].buffer_length = sizeof(int);
+  tags[1].length = &tags[1].buffer_length;
+  tags[1].buffer = &groupId;
+  tags[1].is_null = NULL;
+
+  code = taos_stmt_set_tbname_tags(stmt, "d1001", tags);
+  checkErrorCode(stmt, code, "failed to execute taos_stmt_set_tbname_tags");
+
+  // highlight-start
+  // insert two rows with multi binds
+  TAOS_MULTI_BIND params[4];
+  // values to bind
+  int64_t ts[] = {1648432611249, 1648432611749};
+  float   current[] = {10.3, 12.6};
+  int     voltage[] = {219, 218};
+  float   phase[] = {0.31, 0.33};
+  // is_null array
+  char is_null[2] = {0};
+  // length array
+  int32_t int64Len[2] = {sizeof(int64_t)};
+  int32_t floatLen[2] = {sizeof(float)};
+  int32_t intLen[2] = {sizeof(int)};
+
+  params[0].buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
+  params[0].buffer_length = sizeof(int64_t);
+  params[0].buffer = ts;
+  params[0].length = int64Len;
+  params[0].is_null = is_null;
+  params[0].num = 2;
+
+  params[1].buffer_type = TSDB_DATA_TYPE_FLOAT;
+  params[1].buffer_length = sizeof(float);
+  params[1].buffer = current;
+  params[1].length = floatLen;
+  params[1].is_null = is_null;
+  params[1].num = 2;
+
+  params[2].buffer_type = TSDB_DATA_TYPE_INT;
+  params[2].buffer_length = sizeof(int);
+  params[2].buffer = voltage;
+  params[2].length = intLen;
+  params[2].is_null = is_null;
+  params[2].num = 2;
+
+  params[3].buffer_type = TSDB_DATA_TYPE_FLOAT;
+  params[3].buffer_length = sizeof(float);
+  params[3].buffer = phase;
+  params[3].length = floatLen;
+  params[3].is_null = is_null;
+  params[3].num = 2;
+
+  code = taos_stmt_bind_param_batch(stmt, params); // bind batch
+  checkErrorCode(stmt, code, "failed to execute taos_stmt_bind_param_batch");
+  code = taos_stmt_add_batch(stmt);  // add batch
+  checkErrorCode(stmt, code, "failed to execute taos_stmt_add_batch");
+  // highlight-end
+  // execute
+  code = taos_stmt_execute(stmt);
+  checkErrorCode(stmt, code, "failed to execute taos_stmt_execute");
+  int affectedRows = taos_stmt_affected_rows(stmt);
+  printf("successfully inserted %d rows\n", affectedRows);
+  // close
+  taos_stmt_close(stmt);
+}
+
+int main() {
+  TAOS *taos = taos_connect("localhost", "root", "taosdata", NULL, 6030);
+  if (taos == NULL) {
+    printf("failed to connect to server\n");
+    exit(EXIT_FAILURE);
+  }
+  executeSQL(taos, "DROP DATABASE IF EXISTS power");
+  executeSQL(taos, "CREATE DATABASE power");
+  executeSQL(taos, "USE power");
+  executeSQL(taos,
+             "CREATE STABLE meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS (location BINARY(64), "
+             "groupId INT)");
+  insertData(taos);
+  taos_close(taos);
+  taos_cleanup();
+}
+
+// output:
+// successfully inserted 2 rows
\ No newline at end of file

docs/examples/c/query_example.c

+// compile with:
+// gcc -o query_example query_example.c -ltaos
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <taos.h>
+
+typedef int16_t VarDataLenT;
+
+#define TSDB_NCHAR_SIZE sizeof(int32_t)
+#define VARSTR_HEADER_SIZE sizeof(VarDataLenT)
+
+#define GET_FLOAT_VAL(x) (*(float *)(x))
+#define GET_DOUBLE_VAL(x) (*(double *)(x))
+
+#define varDataLen(v) ((VarDataLenT *)(v))[0]
+
+int printRow(char *str, TAOS_ROW row, TAOS_FIELD *fields, int numFields) {
+  int  len = 0;
+  char split = ' ';
+
+  for (int i = 0; i < numFields; ++i) {
+    if (i > 0) {
+      str[len++] = split;
+    }
+
+    if (row[i] == NULL) {
+      len += sprintf(str + len, "%s", "NULL");
+      continue;
+    }
+
+    switch (fields[i].type) {
+      case TSDB_DATA_TYPE_TINYINT:
+        len += sprintf(str + len, "%d", *((int8_t *)row[i]));
+        break;
+
+      case TSDB_DATA_TYPE_UTINYINT:
+        len += sprintf(str + len, "%u", *((uint8_t *)row[i]));
+        break;
+
+      case TSDB_DATA_TYPE_SMALLINT:
+        len += sprintf(str + len, "%d", *((int16_t *)row[i]));
+        break;
+
+      case TSDB_DATA_TYPE_USMALLINT:
+        len += sprintf(str + len, "%u", *((uint16_t *)row[i]));
+        break;
+
+      case TSDB_DATA_TYPE_INT:
+        len += sprintf(str + len, "%d", *((int32_t *)row[i]));
+        break;
+
+      case TSDB_DATA_TYPE_UINT:
+        len += sprintf(str + len, "%u", *((uint32_t *)row[i]));
+        break;
+
+      case TSDB_DATA_TYPE_BIGINT:
+        len += sprintf(str + len, "%" PRId64, *((int64_t *)row[i]));
+        break;
+
+      case TSDB_DATA_TYPE_UBIGINT:
+        len += sprintf(str + len, "%" PRIu64, *((uint64_t *)row[i]));
+        break;
+
+      case TSDB_DATA_TYPE_FLOAT: {
+        float fv = 0;
+        fv = GET_FLOAT_VAL(row[i]);
+        len += sprintf(str + len, "%f", fv);
+      } break;
+
+      case TSDB_DATA_TYPE_DOUBLE: {
+        double dv = 0;
+        dv = GET_DOUBLE_VAL(row[i]);
+        len += sprintf(str + len, "%lf", dv);
+      } break;
+
+      case TSDB_DATA_TYPE_BINARY:
+      case TSDB_DATA_TYPE_NCHAR: {
+        int32_t charLen = varDataLen((char *)row[i] - VARSTR_HEADER_SIZE);
+        memcpy(str + len, row[i], charLen);
+        len += charLen;
+      } break;
+
+      case TSDB_DATA_TYPE_TIMESTAMP:
+        len += sprintf(str + len, "%" PRId64, *((int64_t *)row[i]));
+        break;
+
+      case TSDB_DATA_TYPE_BOOL:
+        len += sprintf(str + len, "%d", *((int8_t *)row[i]));
+      default:
+        break;
+    }
+  }
+
+  return len;
+}
+
+/**
+ * @brief print column name and values of each row
+ *
+ * @param res
+ * @return int
+ */
+static int printResult(TAOS_RES *res) {
+  int         numFields = taos_num_fields(res);
+  TAOS_FIELD *fields = taos_fetch_fields(res);
+  char        header[256] = {0};
+  int len = 0;
+  for (int i = 0; i < numFields; ++i) {
+    len += sprintf(header + len, "%s ", fields[i].name);
+  }
+  puts(header);
+
+  TAOS_ROW row = NULL;
+  while ((row = taos_fetch_row(res))) {
+    char temp[256] = {0};
+    printRow(temp, row, fields, numFields);
+    puts(temp);
+  }
+}
+
+int main() {
+  TAOS *taos = taos_connect("localhost", "root", "taosdata", "power", 6030);
+  if (taos == NULL) {
+    puts("failed to connect to server");
+    exit(EXIT_FAILURE);
+  }
+  TAOS_RES *res = taos_query(taos, "SELECT * FROM meters LIMIT 2");
+  if (taos_errno(res) != 0) {
+    printf("failed to execute taos_query. error: %s\n", taos_errstr(res));
+    exit(EXIT_FAILURE);
+  }
+  printResult(res);
+  taos_free_result(res);
+  taos_close(taos);
+  taos_cleanup();
+}
+
+// output:
+// ts current voltage phase location groupid 
+// 1648432611249 10.300000 219 0.310000 California.SanFrancisco 2
+// 1648432611749 12.600000 218 0.330000 California.SanFrancisco 2
\ No newline at end of file

docs/examples/c/stmt_example.c

+// compile with
+// gcc -o stmt_example stmt_example.c -ltaos
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "taos.h"
+
+/**
+ * @brief execute sql only.
+ * 
+ * @param taos 
+ * @param sql 
+ */
+void executeSQL(TAOS *taos, const char *sql) {
+  TAOS_RES *res = taos_query(taos, sql);
+  int       code = taos_errno(res);
+  if (code != 0) {
+    printf("%s\n", taos_errstr(res));
+    taos_free_result(res);
+    taos_close(taos);
+    exit(EXIT_FAILURE);
+  }
+  taos_free_result(res);
+}
+
+/**
+ * @brief check return status and exit program when error occur.
+ * 
+ * @param stmt 
+ * @param code 
+ * @param msg 
+ */
+void checkErrorCode(TAOS_STMT *stmt, int code, const char* msg) {
+  if (code != 0) {
+    printf("%s. error: %s\n", msg, taos_stmt_errstr(stmt));
+    taos_stmt_close(stmt);
+    exit(EXIT_FAILURE);
+  }
+}
+
+typedef struct {
+  int64_t ts;
+  float current;
+  int voltage;
+  float phase;
+} Row;
+
+/**
+ * @brief insert data using stmt API
+ * 
+ * @param taos 
+ */
+void insertData(TAOS *taos) {
+  // init
+  TAOS_STMT *stmt = taos_stmt_init(taos);
+  // prepare
+  const char *sql = "INSERT INTO ? USING meters TAGS(?, ?) VALUES(?, ?, ?, ?)";
+  int code = taos_stmt_prepare(stmt, sql, 0);
+  checkErrorCode(stmt, code, "failed to execute taos_stmt_prepare");
+  // bind table name and tags
+  TAOS_BIND tags[2];
+  char* location = "California.SanFrancisco";
+  int groupId = 2;
+  tags[0].buffer_type = TSDB_DATA_TYPE_BINARY;
+  tags[0].buffer_length = strlen(location);
+  tags[0].length = &tags[0].buffer_length;
+  tags[0].buffer = location;
+  tags[0].is_null = NULL;
+  
+  tags[1].buffer_type = TSDB_DATA_TYPE_INT;
+  tags[1].buffer_length = sizeof(int);
+  tags[1].length = &tags[1].buffer_length;
+  tags[1].buffer = &groupId;
+  tags[1].is_null = NULL;
+
+  code = taos_stmt_set_tbname_tags(stmt, "d1001", tags);
+  checkErrorCode(stmt, code, "failed to execute taos_stmt_set_tbname_tags");
+
+  // insert two rows
+  Row rows[2] = {
+    {1648432611249, 10.3, 219, 0.31},
+    {1648432611749, 12.6, 218, 0.33},
+  };
+
+  TAOS_BIND values[4];
+  values[0].buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
+  values[0].buffer_length = sizeof(int64_t);
+  values[0].length = &values[0].buffer_length;
+  values[0].is_null = NULL;
+
+  values[1].buffer_type = TSDB_DATA_TYPE_FLOAT;
+  values[1].buffer_length = sizeof(float);
+  values[1].length = &values[1].buffer_length;
+  values[1].is_null = NULL;
+
+  values[2].buffer_type = TSDB_DATA_TYPE_INT;
+  values[2].buffer_length = sizeof(int);
+  values[2].length = &values[2].buffer_length;
+  values[2].is_null = NULL;
+
+  values[3].buffer_type = TSDB_DATA_TYPE_FLOAT;
+  values[3].buffer_length = sizeof(float);
+  values[3].length = &values[3].buffer_length;
+  values[3].is_null = NULL;
+
+  for (int i = 0; i < 2; ++i) {
+    values[0].buffer = &rows[i].ts;
+    values[1].buffer = &rows[i].current;
+    values[2].buffer = &rows[i].voltage;
+    values[3].buffer = &rows[i].phase;
+    code = taos_stmt_bind_param(stmt, values); // bind param
+    checkErrorCode(stmt, code, "failed to execute taos_stmt_bind_param");
+    code = taos_stmt_add_batch(stmt); // add batch
+    checkErrorCode(stmt, code, "failed to execute taos_stmt_add_batch");
+  }
+  // execute
+  code = taos_stmt_execute(stmt);
+  checkErrorCode(stmt, code, "failed to execute taos_stmt_execute");
+  int affectedRows = taos_stmt_affected_rows(stmt);
+  printf("successfully inserted %d rows\n", affectedRows);
+  // close
+  taos_stmt_close(stmt);
+}
+
+int main() {
+  TAOS *taos = taos_connect("localhost", "root", "taosdata", NULL, 6030);
+  if (taos == NULL) {
+    printf("failed to connect to server\n");
+    exit(EXIT_FAILURE);
+  }
+  executeSQL(taos, "CREATE DATABASE power");
+  executeSQL(taos, "USE power");
+  executeSQL(taos, "CREATE STABLE meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS (location BINARY(64), groupId INT)");
+  insertData(taos);
+  taos_close(taos);
+  taos_cleanup();
+}
+
+
+// output:
+// successfully inserted 2 rows
\ No newline at end of file

docs/examples/c/subscribe_demo.c

+// A simple demo for asynchronous subscription.
+// compile with:
+// gcc -o subscribe_demo subscribe_demo.c -ltaos
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <taos.h>
+
+int nTotalRows;
+
+/**
+ * @brief callback function of subscription.
+ *
+ * @param tsub
+ * @param res
+ * @param param. the additional parameter passed to  taos_subscribe
+ * @param code. error code
+ */
+void subscribe_callback(TAOS_SUB* tsub, TAOS_RES* res, void* param, int code) {
+  if (code != 0) {
+    printf("error: %d\n", code);
+    exit(EXIT_FAILURE);
+  }
+
+  TAOS_ROW    row = NULL;
+  int         num_fields = taos_num_fields(res);
+  TAOS_FIELD* fields = taos_fetch_fields(res);
+  int         nRows = 0;
+
+  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);
+}
+
+int main() {
+  TAOS* taos = taos_connect("localhost", "root", "taosdata", NULL, 6030);
+  if (taos == NULL) {
+    printf("failed to connect to server\n");
+    exit(EXIT_FAILURE);
+  }
+
+  int         restart = 1;  // if the topic already exists, where to subscribe from the begin.
+  const char* topic = "topic-meter-current-bg-10";
+  const char* sql = "select * from power.meters where current > 10";
+  void*       param = NULL;     // additional parameter.
+  int         interval = 2000;  // consumption interval in microseconds.
+  TAOS_SUB*   tsub = taos_subscribe(taos, restart, topic, sql, subscribe_callback, NULL, interval);
+
+  // wait for insert from others process. you can open TDengine CLI to insert some records for test.
+  
+  getchar();  // press Enter to stop
+
+  printf("total rows consumed: %d\n", nTotalRows);
+  int keep = 0;  // whether to keep subscribe process
+  taos_unsubscribe(tsub, keep);
+
+  taos_close(taos);
+  taos_cleanup();
+}

docs/examples/c/telnet_line_example.c

+// compile with
+// gcc -o telnet_line_example telnet_line_example.c -ltaos
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "taos.h"
+
+void executeSQL(TAOS *taos, const char *sql) {
+  TAOS_RES *res = taos_query(taos, sql);
+  int       code = taos_errno(res);
+  if (code != 0) {
+    printf("%s\n", taos_errstr(res));
+    taos_free_result(res);
+    taos_close(taos);
+    exit(EXIT_FAILURE);
+  }
+  taos_free_result(res);
+}
+
+// ANCHOR: main
+int main() {
+  TAOS *taos = taos_connect("localhost", "root", "taosdata", "", 6030);
+  if (taos == NULL) {
+    printf("failed to connect to server\n");
+    exit(EXIT_FAILURE);
+  }
+  executeSQL(taos, "DROP DATABASE IF EXISTS test");
+  executeSQL(taos, "CREATE DATABASE test");
+  executeSQL(taos, "USE test");
+  char *lines[] = {
+      "meters.current 1648432611249 10.3 location=California.SanFrancisco groupid=2",
+      "meters.current 1648432611250 12.6 location=California.SanFrancisco groupid=2",
+      "meters.current 1648432611249 10.8 location=California.LosAngeles groupid=3",
+      "meters.current 1648432611250 11.3 location=California.LosAngeles groupid=3",
+      "meters.voltage 1648432611249 219 location=California.SanFrancisco groupid=2",
+      "meters.voltage 1648432611250 218 location=California.SanFrancisco groupid=2",
+      "meters.voltage 1648432611249 221 location=California.LosAngeles groupid=3",
+      "meters.voltage 1648432611250 217 location=California.LosAngeles groupid=3",
+  };
+  TAOS_RES *res = taos_schemaless_insert(taos, lines, 8, TSDB_SML_TELNET_PROTOCOL, TSDB_SML_TIMESTAMP_NOT_CONFIGURED);
+  if (taos_errno(res) != 0) {
+    printf("failed to insert schema-less data, reason: %s\n", taos_errstr(res));
+  } else {
+    int affectedRow = taos_affected_rows(res);
+    printf("successfully inserted %d rows\n", affectedRow);
+  }
+
+  taos_free_result(res);
+  taos_close(taos);
+  taos_cleanup();
+}
+// output:
+// successfully inserted 8 rows
+// ANCHOR_END: main

docs/examples/c/tmq_example.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include "taos.h"
+
+static int  running = 1;
+static char dbName[64] = "tmqdb";
+static char stbName[64] = "stb";
+static char topicName[64] = "topicname";
+
+static int32_t msg_process(TAOS_RES* msg) {
+  char    buf[1024];
+  int32_t rows = 0;
+
+  const char* topicName = tmq_get_topic_name(msg);
+  const char* dbName = tmq_get_db_name(msg);
+  int32_t     vgroupId = tmq_get_vgroup_id(msg);
+
+  printf("topic: %s\n", topicName);
+  printf("db: %s\n", dbName);
+  printf("vgroup id: %d\n", vgroupId);
+
+  while (1) {
+    TAOS_ROW row = taos_fetch_row(msg);
+    if (row == NULL) break;
+
+    TAOS_FIELD* fields = taos_fetch_fields(msg);
+    int32_t     numOfFields = taos_field_count(msg);
+    int32_t*    length = taos_fetch_lengths(msg);
+    int32_t     precision = taos_result_precision(msg);
+    rows++;
+    taos_print_row(buf, row, fields, numOfFields);
+    printf("row content: %s\n", buf);
+  }
+
+  return rows;
+}
+
+static int32_t init_env() {
+  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  if (pConn == NULL) {
+    return -1;
+  }
+
+  TAOS_RES* pRes;
+  // drop database if exists
+  printf("create database\n");
+  pRes = taos_query(pConn, "drop database if exists tmqdb");
+  if (taos_errno(pRes) != 0) {
+    printf("error in drop tmqdb, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  // create database
+  pRes = taos_query(pConn, "create database tmqdb");
+  if (taos_errno(pRes) != 0) {
+    printf("error in create tmqdb, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  // create super table
+  printf("create super table\n");
+  pRes = taos_query(
+      pConn, "create table tmqdb.stb (ts timestamp, c1 int, c2 float, c3 varchar(16)) tags(t1 int, t3 varchar(16))");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create super table stb, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  // create sub tables
+  printf("create sub tables\n");
+  pRes = taos_query(pConn, "create table tmqdb.ctb0 using tmqdb.stb tags(0, 'subtable0')");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create super table ctb0, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create table tmqdb.ctb1 using tmqdb.stb tags(1, 'subtable1')");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create super table ctb1, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create table tmqdb.ctb2 using tmqdb.stb tags(2, 'subtable2')");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create super table ctb2, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create table tmqdb.ctb3 using tmqdb.stb tags(3, 'subtable3')");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create super table ctb3, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  // insert data
+  printf("insert data into sub tables\n");
+  pRes = taos_query(pConn, "insert into tmqdb.ctb0 values(now, 0, 0, 'a0')(now+1s, 0, 0, 'a00')");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to insert into ctb0, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "insert into tmqdb.ctb1 values(now, 1, 1, 'a1')(now+1s, 11, 11, 'a11')");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to insert into ctb0, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "insert into tmqdb.ctb2 values(now, 2, 2, 'a1')(now+1s, 22, 22, 'a22')");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to insert into ctb0, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "insert into tmqdb.ctb3 values(now, 3, 3, 'a1')(now+1s, 33, 33, 'a33')");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to insert into ctb0, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  taos_close(pConn);
+  return 0;
+}
+
+int32_t create_topic() {
+  printf("create topic\n");
+  TAOS_RES* pRes;
+  TAOS*     pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  if (pConn == NULL) {
+    return -1;
+  }
+
+  pRes = taos_query(pConn, "use tmqdb");
+  if (taos_errno(pRes) != 0) {
+    printf("error in use tmqdb, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create topic topicname as select ts, c1, c2, c3, tbname from tmqdb.stb where c1 > 1");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create topic topicname, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  taos_close(pConn);
+  return 0;
+}
+
+void tmq_commit_cb_print(tmq_t* tmq, int32_t code, void* param) {
+  printf("tmq_commit_cb_print() code: %d, tmq: %p, param: %p\n", code, tmq, param);
+}
+
+tmq_t* build_consumer() {
+  tmq_conf_res_t code;
+  tmq_conf_t*    conf = tmq_conf_new();
+  code = tmq_conf_set(conf, "enable.auto.commit", "true");
+  if (TMQ_CONF_OK != code) return NULL;
+  code = tmq_conf_set(conf, "auto.commit.interval.ms", "1000");
+  if (TMQ_CONF_OK != code) return NULL;
+  code = tmq_conf_set(conf, "group.id", "cgrpName");
+  if (TMQ_CONF_OK != code) return NULL;
+  code = tmq_conf_set(conf, "client.id", "user defined name");
+  if (TMQ_CONF_OK != code) return NULL;
+  code = tmq_conf_set(conf, "td.connect.user", "root");
+  if (TMQ_CONF_OK != code) return NULL;
+  code = tmq_conf_set(conf, "td.connect.pass", "taosdata");
+  if (TMQ_CONF_OK != code) return NULL;
+  code = tmq_conf_set(conf, "auto.offset.reset", "earliest");
+  if (TMQ_CONF_OK != code) return NULL;
+  code = tmq_conf_set(conf, "experimental.snapshot.enable", "false");
+  if (TMQ_CONF_OK != code) return NULL;
+
+  tmq_conf_set_auto_commit_cb(conf, tmq_commit_cb_print, NULL);
+
+  tmq_t* tmq = tmq_consumer_new(conf, NULL, 0);
+  tmq_conf_destroy(conf);
+  return tmq;
+}
+
+tmq_list_t* build_topic_list() {
+  tmq_list_t* topicList = tmq_list_new();
+  int32_t     code = tmq_list_append(topicList, "topicname");
+  if (code) {
+    return NULL;
+  }
+  return topicList;
+}
+
+void basic_consume_loop(tmq_t* tmq) {
+  int32_t totalRows = 0;
+  int32_t msgCnt = 0;
+  int32_t timeout = 5000;
+  while (running) {
+    TAOS_RES* tmqmsg = tmq_consumer_poll(tmq, timeout);
+    if (tmqmsg) {
+      msgCnt++;
+      totalRows += msg_process(tmqmsg);
+      taos_free_result(tmqmsg);
+    } else {
+      break;
+    }
+  }
+
+  fprintf(stderr, "%d msg consumed, include %d rows\n", msgCnt, totalRows);
+}
+
+int main(int argc, char* argv[]) {
+  int32_t code;
+
+  if (init_env() < 0) {
+    return -1;
+  }
+
+  if (create_topic() < 0) {
+    return -1;
+  }
+
+  tmq_t* tmq = build_consumer();
+  if (NULL == tmq) {
+    fprintf(stderr, "%% build_consumer() fail!\n");
+    return -1;
+  }
+
+  tmq_list_t* topic_list = build_topic_list();
+  if (NULL == topic_list) {
+    return -1;
+  }
+
+  if ((code = tmq_subscribe(tmq, topic_list))) {
+    fprintf(stderr, "%% Failed to tmq_subscribe(): %s\n", tmq_err2str(code));
+  }
+  tmq_list_destroy(topic_list);
+
+  basic_consume_loop(tmq);
+
+  code = tmq_consumer_close(tmq);
+  if (code) {
+    fprintf(stderr, "%% Failed to close consumer: %s\n", tmq_err2str(code));
+  } else {
+    fprintf(stderr, "%% Consumer closed\n");
+  }
+
+  return 0;
+}

docs/examples/csharp/.gitignore

+bin
+obj
+.vs
+*.sln
\ No newline at end of file

docs/examples/csharp/AsyncQueryExample.cs

+using System;
+using System.Collections.Generic;
+using TDengineDriver;
+using TDengineDriver.Impl;
+using System.Runtime.InteropServices;
+
+namespace TDengineExample
+{
+    public class AsyncQueryExample
+    {
+        static void Main()
+        {
+            IntPtr conn = GetConnection();
+            QueryAsyncCallback queryAsyncCallback = new QueryAsyncCallback(QueryCallback);
+            TDengine.QueryAsync(conn, "select * from meters", queryAsyncCallback, IntPtr.Zero);
+            Thread.Sleep(2000);
+            TDengine.Close(conn);
+            TDengine.Cleanup();
+        }
+
+        static void QueryCallback(IntPtr param, IntPtr taosRes, int code)
+        {
+            if (code == 0 && taosRes != IntPtr.Zero)
+            {
+                FetchRawBlockAsyncCallback fetchRowAsyncCallback = new FetchRawBlockAsyncCallback(FetchRawBlockCallback);
+                TDengine.FetchRawBlockAsync(taosRes, fetchRowAsyncCallback, param);
+            }
+            else
+            {
+                Console.WriteLine($"async query data failed, failed code {code}");
+            }
+        }
+
+               // Iteratively call this interface until "numOfRows" is no greater than 0.
+        static void FetchRawBlockCallback(IntPtr param, IntPtr taosRes, int numOfRows)
+        {
+            if (numOfRows > 0)
+            {
+                Console.WriteLine($"{numOfRows} rows async retrieved");
+                IntPtr pdata = TDengine.GetRawBlock(taosRes);
+                List<TDengineMeta> metaList = TDengine.FetchFields(taosRes);
+                List<object> dataList = LibTaos.ReadRawBlock(pdata, metaList, numOfRows);
+
+                for (int i = 0; i < dataList.Count; i++)
+                {
+                    if (i != 0 && (i+1) % metaList.Count == 0)
+                    {
+                        Console.WriteLine("{0}\t|", dataList[i]);
+                    }
+                    else
+                    {
+                        Console.Write("{0}\t|", dataList[i]);
+                    }
+                }
+                Console.WriteLine("");
+                TDengine.FetchRawBlockAsync(taosRes, FetchRawBlockCallback, param);
+            }
+            else
+            {
+                if (numOfRows == 0)
+                {
+                    Console.WriteLine("async retrieve complete.");
+                }
+                else
+                {
+                    Console.WriteLine($"FetchRawBlockCallback callback error, error code {numOfRows}");
+                }
+                TDengine.FreeResult(taosRes);
+            }
+        }
+
+        static IntPtr GetConnection()
+        {
+            string host = "localhost";
+            short port = 6030;
+            string username = "root";
+            string password = "taosdata";
+            string dbname = "power";
+            var conn = TDengine.Connect(host, username, password, dbname, port);
+            if (conn == IntPtr.Zero)
+            {
+                Console.WriteLine("Connect to TDengine failed");
+                Environment.Exit(0);
+            }
+            else
+            {
+                Console.WriteLine("Connect to TDengine success");
+            }
+            return conn;
+        }
+    }
+}
+
+// //output:
+// // Connect to TDengine success
+// // 8 rows async retrieved
+
+// // 1538548685500   |       11.8    |       221     |       0.28    |       california.losangeles   |       2       |
+// // 1538548696600   |       13.4    |       223     |       0.29    |       california.losangeles   |       2       |
+// // 1538548685000   |       10.8    |       223     |       0.29    |       california.losangeles   |       3       |
+// // 1538548686500   |       11.5    |       221     |       0.35    |       california.losangeles   |       3       |
+// // 1538548685000   |       10.3    |       219     |       0.31    |       california.sanfrancisco         |       2       |
+// // 1538548695000   |       12.6    |       218     |       0.33    |       california.sanfrancisco         |       2       |
+// // 1538548696800   |       12.3    |       221     |       0.31    |       california.sanfrancisco         |       2       |
+// // 1538548696650   |       10.3    |       218     |       0.25    |       california.sanfrancisco         |       3       |
+// // async retrieve complete.
\ No newline at end of file

docs/examples/csharp/ConnectExample.cs

+using TDengineDriver;
+
+namespace TDengineExample
+{
+
+    internal class ConnectExample
+    {
+        static void Main(String[] args)
+        {
+            string host = "localhost";
+            short port = 6030;
+            string username = "root";
+            string password = "taosdata";
+            string dbname = "";
+
+            var conn = TDengine.Connect(host, username, password, dbname, port);
+            if (conn == IntPtr.Zero)
+            {
+                Console.WriteLine("Connect to TDengine failed");
+            }
+            else
+            {
+                Console.WriteLine("Connect to TDengine success");
+            }
+            TDengine.Close(conn);
+            TDengine.Cleanup();
+        }
+    }
+}

docs/examples/csharp/InfluxDBLineExample.cs

+using TDengineDriver;
+
+namespace TDengineExample
+{
+    internal class InfluxDBLineExample
+    {
+        static void Main()
+        {
+            IntPtr conn = GetConnection();
+            PrepareDatabase(conn);
+            string[] lines = {
+                "meters,location=California.LosAngeles,groupid=2 current=11.8,voltage=221,phase=0.28 1648432611249",
+                "meters,location=California.LosAngeles,groupid=2 current=13.4,voltage=223,phase=0.29 1648432611250",
+                "meters,location=California.LosAngeles,groupid=3 current=10.8,voltage=223,phase=0.29 1648432611249",
+                "meters,location=California.LosAngeles,groupid=3 current=11.3,voltage=221,phase=0.35 1648432611250"
+            };
+            IntPtr res = TDengine.SchemalessInsert(conn, lines, lines.Length, (int)TDengineSchemalessProtocol.TSDB_SML_LINE_PROTOCOL, (int)TDengineSchemalessPrecision.TSDB_SML_TIMESTAMP_MILLI_SECONDS);
+            if (TDengine.ErrorNo(res) != 0)
+            {
+                Console.WriteLine("SchemalessInsert failed since " + TDengine.Error(res));
+                ExitProgram(conn, 1);
+            }
+            else
+            {
+                int affectedRows = TDengine.AffectRows(res);
+                Console.WriteLine($"SchemalessInsert success, affected {affectedRows} rows");
+            }
+            TDengine.FreeResult(res);
+            ExitProgram(conn, 0);
+
+        }
+        static IntPtr GetConnection()
+        {
+            string host = "localhost";
+            short port = 6030;
+            string username = "root";
+            string password = "taosdata";
+            string dbname = "";
+            var conn = TDengine.Connect(host, username, password, dbname, port);
+            if (conn == IntPtr.Zero)
+            {
+                Console.WriteLine("Connect to TDengine failed");
+                TDengine.Cleanup();
+                Environment.Exit(1);
+            }
+            else
+            {
+                Console.WriteLine("Connect to TDengine success");
+            }
+            return conn;
+        }
+
+        static void PrepareDatabase(IntPtr conn)
+        {
+            IntPtr res = TDengine.Query(conn, "CREATE DATABASE test");
+            if (TDengine.ErrorNo(res) != 0)
+            {
+                Console.WriteLine("failed to create database, reason: " + TDengine.Error(res));
+                ExitProgram(conn, 1);
+            }
+            res = TDengine.Query(conn, "USE test");
+            if (TDengine.ErrorNo(res) != 0)
+            {
+                Console.WriteLine("failed to change database, reason: " + TDengine.Error(res));
+                ExitProgram(conn, 1);
+            }
+        }
+
+        static void ExitProgram(IntPtr conn, int exitCode)
+        {
+            TDengine.Close(conn);
+            TDengine.Cleanup();
+            Environment.Exit(exitCode);
+        }
+    }
+
+}

docs/examples/csharp/OptsJsonExample.cs

+using TDengineDriver;
+
+namespace TDengineExample
+{
+    internal class OptsJsonExample
+    {
+        static void Main()
+        {
+            IntPtr conn = GetConnection();
+            PrepareDatabase(conn);
+            string[] lines = { "[{\"metric\": \"meters.current\", \"timestamp\": 1648432611249, \"value\": 10.3, \"tags\": {\"location\": \"California.SanFrancisco\", \"groupid\": 2}}," +
+                " {\"metric\": \"meters.voltage\", \"timestamp\": 1648432611249, \"value\": 219, \"tags\": {\"location\": \"California.LosAngeles\", \"groupid\": 1}}, " +
+                "{\"metric\": \"meters.current\", \"timestamp\": 1648432611250, \"value\": 12.6, \"tags\": {\"location\": \"California.SanFrancisco\", \"groupid\": 2}}," +
+                " {\"metric\": \"meters.voltage\", \"timestamp\": 1648432611250, \"value\": 221, \"tags\": {\"location\": \"California.LosAngeles\", \"groupid\": 1}}]"
+            };
+
+            IntPtr res = TDengine.SchemalessInsert(conn, lines, 1, (int)TDengineSchemalessProtocol.TSDB_SML_JSON_PROTOCOL, (int)TDengineSchemalessPrecision.TSDB_SML_TIMESTAMP_NOT_CONFIGURED);
+            if (TDengine.ErrorNo(res) != 0)
+            {
+                Console.WriteLine("SchemalessInsert failed since " + TDengine.Error(res));
+                ExitProgram(conn, 1);
+            }
+            else
+            {
+                int affectedRows = TDengine.AffectRows(res);
+                Console.WriteLine($"SchemalessInsert success, affected {affectedRows} rows");
+            }
+            TDengine.FreeResult(res);
+            ExitProgram(conn, 0);
+
+        }
+        static IntPtr GetConnection()
+        {
+            string host = "localhost";
+            short port = 6030;
+            string username = "root";
+            string password = "taosdata";
+            string dbname = "";
+            var conn = TDengine.Connect(host, username, password, dbname, port);
+            if (conn == IntPtr.Zero)
+            {
+                Console.WriteLine("Connect to TDengine failed");
+                TDengine.Cleanup();
+                Environment.Exit(1);
+            }
+            else
+            {
+                Console.WriteLine("Connect to TDengine success");
+            }
+            return conn;
+        }
+
+        static void PrepareDatabase(IntPtr conn)
+        {
+            IntPtr res = TDengine.Query(conn, "CREATE DATABASE test");
+            if (TDengine.ErrorNo(res) != 0)
+            {
+                Console.WriteLine("failed to create database, reason: " + TDengine.Error(res));
+                ExitProgram(conn, 1);
+            }
+            res = TDengine.Query(conn, "USE test");
+            if (TDengine.ErrorNo(res) != 0)
+            {
+                Console.WriteLine("failed to change database, reason: " + TDengine.Error(res));
+                ExitProgram(conn, 1);
+            }
+        }
+
+        static void ExitProgram(IntPtr conn, int exitCode)
+        {
+            TDengine.Close(conn);
+            TDengine.Cleanup();
+            Environment.Exit(exitCode);
+        }
+    }
+}

docs/examples/csharp/OptsTelnetExample.cs

+using TDengineDriver;
+
+namespace TDengineExample
+{
+    internal class OptsTelnetExample
+    {
+        static void Main()
+        {
+            IntPtr conn = GetConnection();
+            PrepareDatabase(conn);
+            string[] lines = {
+                "meters.current 1648432611249 10.3 location=California.SanFrancisco groupid=2",
+                "meters.current 1648432611250 12.6 location=California.SanFrancisco groupid=2",
+                "meters.current 1648432611249 10.8 location=California.LosAngeles groupid=3",
+                "meters.current 1648432611250 11.3 location=California.LosAngeles groupid=3",
+                "meters.voltage 1648432611249 219 location=California.SanFrancisco groupid=2",
+                "meters.voltage 1648432611250 218 location=California.SanFrancisco groupid=2",
+                "meters.voltage 1648432611249 221 location=California.LosAngeles groupid=3",
+                "meters.voltage 1648432611250 217 location=California.LosAngeles groupid=3",
+            };
+            IntPtr res = TDengine.SchemalessInsert(conn, lines, lines.Length, (int)TDengineSchemalessProtocol.TSDB_SML_TELNET_PROTOCOL, (int)TDengineSchemalessPrecision.TSDB_SML_TIMESTAMP_NOT_CONFIGURED);
+            if (TDengine.ErrorNo(res) != 0)
+            {
+                Console.WriteLine("SchemalessInsert failed since " + TDengine.Error(res));
+                ExitProgram(conn, 1);
+            }
+            else
+            {
+                int affectedRows = TDengine.AffectRows(res);
+                Console.WriteLine($"SchemalessInsert success, affected {affectedRows} rows");
+            }
+            TDengine.FreeResult(res);
+            ExitProgram(conn, 0);
+
+        }
+        static IntPtr GetConnection()
+        {
+            string host = "localhost";
+            short port = 6030;
+            string username = "root";
+            string password = "taosdata";
+            string dbname = "";
+            var conn = TDengine.Connect(host, username, password, dbname, port);
+            if (conn == IntPtr.Zero)
+            {
+                Console.WriteLine("Connect to TDengine failed");
+                TDengine.Cleanup();
+                Environment.Exit(1);
+            }
+            else
+            {
+                Console.WriteLine("Connect to TDengine success");
+            }
+            return conn;
+        }
+
+        static void PrepareDatabase(IntPtr conn)
+        {
+            IntPtr res = TDengine.Query(conn, "CREATE DATABASE test");
+            if (TDengine.ErrorNo(res) != 0)
+            {
+                Console.WriteLine("failed to create database, reason: " + TDengine.Error(res));
+                ExitProgram(conn, 1);
+            }
+            res = TDengine.Query(conn, "USE test");
+            if (TDengine.ErrorNo(res) != 0)
+            {
+                Console.WriteLine("failed to change database, reason: " + TDengine.Error(res));
+                ExitProgram(conn, 1);
+            }
+        }
+
+        static void ExitProgram(IntPtr conn, int exitCode)
+        {
+            TDengine.Close(conn);
+            TDengine.Cleanup();
+            Environment.Exit(exitCode);
+        }
+    }
+}

docs/examples/csharp/QueryExample.cs

+using TDengineDriver;
+using TDengineDriver.Impl;
+using System.Runtime.InteropServices;
+
+namespace TDengineExample
+{
+    internal class QueryExample
+    {
+        static void Main()
+        {
+            IntPtr conn = GetConnection();
+            // run query
+            IntPtr res = TDengine.Query(conn, "SELECT * FROM meters LIMIT 2");
+            if (TDengine.ErrorNo(res) != 0)
+            {
+                Console.WriteLine("Failed to query since: " + TDengine.Error(res));
+                TDengine.Close(conn);
+                TDengine.Cleanup();
+                return;
+            }
+
+            // get filed count
+            int fieldCount = TDengine.FieldCount(res);
+            Console.WriteLine("fieldCount=" + fieldCount);
+
+            // print column names
+            List<TDengineMeta> metas = LibTaos.GetMeta(res);
+            for (int i = 0; i < metas.Count; i++)
+            {
+                Console.Write(metas[i].name + "\t");
+            }
+            Console.WriteLine();
+
+            // print values
+            List<Object> resData = LibTaos.GetData(res);
+            for (int i = 0; i < resData.Count; i++)
+            {
+                Console.Write($"|{resData[i].ToString()} \t");
+                if (((i + 1) % metas.Count == 0))
+                {
+                    Console.WriteLine("");
+                }
+            }
+            Console.WriteLine();
+            
+            if (TDengine.ErrorNo(res) != 0)
+            {
+                Console.WriteLine($"Query is not complete, Error {TDengine.ErrorNo(res)} {TDengine.Error(res)}");
+            }
+            // exit
+            TDengine.FreeResult(res);
+            TDengine.Close(conn);
+            TDengine.Cleanup();
+        }
+        static IntPtr GetConnection()
+        {
+            string host = "localhost";
+            short port = 6030;
+            string username = "root";
+            string password = "taosdata";
+            string dbname = "power";
+            var conn = TDengine.Connect(host, username, password, dbname, port);
+            if (conn == IntPtr.Zero)
+            {
+                Console.WriteLine("Connect to TDengine failed");
+                System.Environment.Exit(0);
+            }
+            else
+            {
+                Console.WriteLine("Connect to TDengine success");
+            }
+            return conn;
+        }
+    }
+}
+
+// output:
+// Connect to TDengine success
+// fieldCount=6
+// ts      current voltage phase   location        groupid
+// 1648432611249   10.3    219     0.31    California.SanFrancisco        2
+// 1648432611749   12.6    218     0.33    California.SanFrancisco        2
\ No newline at end of file

docs/examples/csharp/SQLInsertExample.cs

+using TDengineDriver;
+
+
+namespace TDengineExample
+{
+    internal class SQLInsertExample
+    {
+
+        static void Main()
+        {
+            IntPtr conn = GetConnection();
+            IntPtr res = TDengine.Query(conn, "CREATE DATABASE power");
+            CheckRes(conn, res, "failed to create database");
+            res = TDengine.Query(conn, "USE power");
+            CheckRes(conn, res, "failed to change database");
+            res = TDengine.Query(conn, "CREATE STABLE power.meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS (location BINARY(64), groupId INT)");
+            CheckRes(conn, res, "failed to create stable");
+            var sql = "INSERT INTO d1001 USING meters TAGS('California.SanFrancisco', 2) VALUES ('2018-10-03 14:38:05.000', 10.30000, 219, 0.31000) ('2018-10-03 14:38:15.000', 12.60000, 218, 0.33000) ('2018-10-03 14:38:16.800', 12.30000, 221, 0.31000) " +
+                        "d1002 USING power.meters TAGS('California.SanFrancisco', 3) VALUES('2018-10-03 14:38:16.650', 10.30000, 218, 0.25000) " +
+                        "d1003 USING power.meters TAGS('California.LosAngeles', 2) VALUES('2018-10-03 14:38:05.500', 11.80000, 221, 0.28000)('2018-10-03 14:38:16.600', 13.40000, 223, 0.29000) " +
+                        "d1004 USING power.meters TAGS('California.LosAngeles', 3) VALUES('2018-10-03 14:38:05.000', 10.80000, 223, 0.29000)('2018-10-03 14:38:06.500', 11.50000, 221, 0.35000)";
+            res = TDengine.Query(conn, sql);
+            CheckRes(conn, res, "failed to insert data");
+            int affectedRows = TDengine.AffectRows(res);
+            Console.WriteLine("affectedRows " + affectedRows);
+            ExitProgram(conn, 0);
+        }
+
+        static IntPtr GetConnection()
+        {
+            string host = "localhost";
+            short port = 6030;
+            string username = "root";
+            string password = "taosdata";
+            string dbname = "";
+            var conn = TDengine.Connect(host, username, password, dbname, port);
+            if (conn == IntPtr.Zero)
+            {
+                Console.WriteLine("Connect to TDengine failed");
+                Environment.Exit(0);
+            }
+            else
+            {
+                Console.WriteLine("Connect to TDengine success");
+            }
+            return conn;
+        }
+
+        static void CheckRes(IntPtr conn, IntPtr res, String errorMsg)
+        {
+            if (TDengine.ErrorNo(res) != 0)
+            {
+                Console.Write(errorMsg + " since: " + TDengine.Error(res));
+                ExitProgram(conn, 1);
+            }
+        }
+
+        static void ExitProgram(IntPtr conn, int exitCode)
+        {
+            TDengine.Close(conn);
+            TDengine.Cleanup();
+            Environment.Exit(exitCode);
+        }
+    }
+}
+
+// output:
+// Connect to TDengine success
+// affectedRows 8

docs/examples/csharp/StmtInsertExample.cs

+using TDengineDriver;
+
+namespace TDengineExample
+{
+    internal class StmtInsertExample
+    {
+        private static IntPtr conn;
+        private static IntPtr stmt;
+        static void Main()
+        {
+            conn = GetConnection();
+            PrepareSTable();
+            // 1. init and prepare
+            stmt = TDengine.StmtInit(conn);
+            if (stmt == IntPtr.Zero)
+            {
+                Console.WriteLine("failed to init stmt, " + TDengine.Error(stmt));
+                ExitProgram();
+            }
+            int res = TDengine.StmtPrepare(stmt, "INSERT INTO ? USING meters TAGS(?, ?) VALUES(?, ?, ?, ?)");
+            CheckStmtRes(res, "failed to prepare stmt");
+
+            // 2. bind table name and tags
+            TAOS_MULTI_BIND[] tags = new TAOS_MULTI_BIND[2] { TaosMultiBind.MultiBindBinary(new string[]{"California.SanFrancisco"}), TaosMultiBind.MultiBindInt(new int?[] {2}) };
+            res = TDengine.StmtSetTbnameTags(stmt, "d1001", tags);
+            CheckStmtRes(res, "failed to bind table name and tags");
+
+            // 3. bind values
+            TAOS_MULTI_BIND[] values = new TAOS_MULTI_BIND[4] {
+                TaosMultiBind.MultiBindTimestamp(new long[2] { 1648432611249, 1648432611749}),
+                TaosMultiBind.MultiBindFloat(new float?[2] { 10.3f, 12.6f}),
+                TaosMultiBind.MultiBindInt(new int?[2] { 219, 218}),
+                TaosMultiBind.MultiBindFloat(new float?[2]{ 0.31f, 0.33f})
+            };
+            res = TDengine.StmtBindParamBatch(stmt, values);
+            CheckStmtRes(res, "failed to bind params");
+
+            // 4. add batch
+            res = TDengine.StmtAddBatch(stmt);
+            CheckStmtRes(res, "failed to add batch");
+
+            // 5. execute
+            res = TDengine.StmtExecute(stmt);
+            CheckStmtRes(res, "faild to execute");
+
+            // 6. free 
+            TaosMultiBind.FreeTaosBind(tags);
+            TaosMultiBind.FreeTaosBind(values);
+            TDengine.Close(conn);
+            TDengine.Cleanup();
+        }
+
+        static IntPtr GetConnection()
+        {
+            string host = "localhost";
+            short port = 6030;
+            string username = "root";
+            string password = "taosdata";
+            string dbname = "";
+            var conn = TDengine.Connect(host, username, password, dbname, port);
+            if (conn == IntPtr.Zero)
+            {
+                Console.WriteLine("Connect to TDengine failed");
+                Environment.Exit(0);
+            }
+            else
+            {
+                Console.WriteLine("Connect to TDengine success");
+            }
+            return conn;
+        }
+
+
+
+        static void PrepareSTable()
+        {
+            IntPtr res = TDengine.Query(conn, "CREATE DATABASE power");
+            CheckResPtr(res, "failed to create database");
+            res = TDengine.Query(conn, "USE power");
+            CheckResPtr(res, "failed to change database");
+            res = TDengine.Query(conn, "CREATE STABLE power.meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS (location BINARY(64), groupId INT)");
+            CheckResPtr(res, "failed to create stable");
+        }
+
+        static void CheckStmtRes(int res, string errorMsg)
+        {
+            if (res != 0)
+            {
+                Console.WriteLine(errorMsg + ", " + TDengine.StmtErrorStr(stmt));
+                int code = TDengine.StmtClose(stmt);
+                if (code != 0)
+                {
+                    Console.WriteLine($"falied to close stmt, {code} reason: {TDengine.StmtErrorStr(stmt)} ");
+                }
+                ExitProgram();
+            }
+        }
+
+        static void CheckResPtr(IntPtr res, string errorMsg)
+        {
+            if (TDengine.ErrorNo(res) != 0)
+            {
+                Console.WriteLine(errorMsg + " since:" + TDengine.Error(res));
+                ExitProgram();
+            }
+        }
+
+        static void ExitProgram()
+        {
+            TDengine.Close(conn);
+            TDengine.Cleanup();
+            Environment.Exit(1);
+        }
+    }
+}

docs/examples/csharp/SubscribeDemo.cs

+using System;
+using TDengineTMQ;
+using TDengineDriver;
+using System.Runtime.InteropServices;
+
+namespace TMQExample
+{
+    internal class SubscribeDemo
+    {
+        static void Main(string[] args)
+        {
+            IntPtr conn = GetConnection();
+            string topic = "topic_example";
+            Console.WriteLine($"create topic if not exist {topic} as select * from meters");
+            //create topic 
+            IntPtr res = TDengine.Query(conn, $"create topic if not exists {topic} as select * from meters");
+           
+            if (res == IntPtr.Zero)
+            {
+                throw new Exception($"create topic failed, reason:{TDengine.Error(res)}");
+            }
+
+            var cfg = new ConsumerConfig
+            {
+                GourpId = "group_1",
+                TDConnectUser = "root",
+                TDConnectPasswd = "taosdata",
+                MsgWithTableName = "true",
+                TDConnectIp = "127.0.0.1",                
+            };
+
+            // create consumer 
+            var consumer = new ConsumerBuilder(cfg)
+                .Build();
+
+            // subscribe
+            consumer.Subscribe(topic);
+
+            // consume 
+            for (int i = 0; i < 5; i++)
+            {
+                var consumeRes = consumer.Consume(300);
+                // print consumeResult
+                foreach (KeyValuePair<TopicPartition, TaosResult> kv in consumeRes.Message)
+                {
+                    Console.WriteLine("topic partitions:\n{0}", kv.Key.ToString());
+
+                    kv.Value.Metas.ForEach(meta =>
+                    {
+                        Console.Write("{0} {1}({2}) \t|", meta.name, meta.TypeName(), meta.size);
+                    });
+                    Console.WriteLine("");
+                    kv.Value.Datas.ForEach(data =>
+                    {
+                        Console.WriteLine(data.ToString());
+                    });
+                }
+
+                consumer.Commit(consumeRes);
+                Console.WriteLine("\n================ {0} done ", i);
+
+            }
+
+            // retrieve topic list
+            List<string> topics = consumer.Subscription();
+            topics.ForEach(t => Console.WriteLine("topic name:{0}", t));
+
+
+            // unsubscribe
+            consumer.Unsubscribe();
+
+            // close consumer after use.Otherwise will lead memory leak.
+            consumer.Close();
+            TDengine.Close(conn);
+
+
+        }
+
+        static IntPtr GetConnection()
+        {
+            string host = "localhost";
+            short port = 6030;
+            string username = "root";
+            string password = "taosdata";
+            string dbname = "power";
+            var conn = TDengine.Connect(host, username, password, dbname, port);
+            if (conn == IntPtr.Zero)
+            {
+                Console.WriteLine("Connect to TDengine failed");
+                System.Environment.Exit(0);
+            }
+            else
+            {
+                Console.WriteLine("Connect to TDengine success");
+            }
+            return conn;
+        }
+    }
+
+}

docs/examples/csharp/asyncquery.csproj

+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <StartupObject>TDengineExample.AsyncQueryExample</StartupObject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="TDengine.Connector" Version="3.0.0" />
+  </ItemGroup>
+
+</Project>

docs/examples/csharp/connect.csproj

+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <StartupObject>TDengineExample.ConnectExample</StartupObject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="TDengine.Connector" Version="3.0.0" />
+  </ItemGroup>
+
+</Project>

docs/examples/csharp/influxdbline.csproj

+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <StartupObject>TDengineExample.InfluxDBLineExample</StartupObject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="TDengine.Connector" Version="3.0.0" />
+  </ItemGroup>
+
+</Project>

docs/examples/csharp/optsjson.csproj

+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <StartupObject>TDengineExample.OptsJsonExample</StartupObject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="TDengine.Connector" Version="3.0.0" />
+  </ItemGroup>
+
+</Project>

docs/examples/csharp/optstelnet.csproj

+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <StartupObject>TDengineExample.OptsTelnetExample</StartupObject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="TDengine.Connector" Version="3.0.0" />
+  </ItemGroup>
+
+</Project>

docs/examples/csharp/query.csproj

+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <StartupObject>TDengineExample.QueryExample</StartupObject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="TDengine.Connector" Version="3.0.0" />
+  </ItemGroup>
+
+</Project>

docs/examples/csharp/sqlinsert.csproj

+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <StartupObject>TDengineExample.SQLInsertExample</StartupObject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="TDengine.Connector" Version="3.0.0" />
+  </ItemGroup>
+
+</Project>

docs/examples/csharp/stmtinsert.csproj

+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <StartupObject>TDengineExample.StmtInsertExample</StartupObject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="TDengine.Connector" Version="3.0.0" />
+  </ItemGroup>
+
+</Project>

docs/examples/csharp/subscribe.csproj

+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <StartupObject>TMQExample.SubscribeDemo</StartupObject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="TDengine.Connector" Version="3.0.0" />
+  </ItemGroup>
+
+</Project>

docs/examples/go/.gitignore

+.idea
+.vscode
+tmp/
\ No newline at end of file

docs/examples/go/connect/afconn/main.go

+package main
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/taosdata/driver-go/v3/af"
+)
+
+func main() {
+	conn, err := af.Open("localhost", "root", "taosdata", "", 6030)
+	defer conn.Close()
+	if err != nil {
+		log.Fatalln("failed to connect, err:", err)
+	} else {
+		fmt.Println("connected")
+	}
+}

docs/examples/go/connect/cgoexample/main.go

+package main
+
+import (
+	"database/sql"
+	"fmt"
+	"log"
+
+	_ "github.com/taosdata/driver-go/v3/taosSql"
+)
+
+func main() {
+	var taosDSN = "root:taosdata@tcp(localhost:6030)/"
+	taos, err := sql.Open("taosSql", taosDSN)
+	if err != nil {
+		log.Fatalln("failed to connect TDengine, err:", err)
+		return
+	}
+	fmt.Println("Connected")
+	defer taos.Close()
+}
+
+// use
+// var taosDSN = "root:taosdata@tcp(localhost:6030)/dbName"
+// if you want to connect a specified database named "dbName".

docs/examples/go/connect/restexample/main.go

+package main
+
+import (
+	"database/sql"
+	"fmt"
+	"log"
+
+	_ "github.com/taosdata/driver-go/v3/taosRestful"
+)
+
+func main() {
+	var taosDSN = "root:taosdata@http(localhost:6041)/"
+	taos, err := sql.Open("taosRestful", taosDSN)
+	if err != nil {
+		log.Fatalln("failed to connect TDengine, err:", err)
+		return
+	}
+	fmt.Println("Connected")
+	defer taos.Close()
+}
+
+// use
+// var taosDSN = "root:taosdata@http(localhost:6041)/dbName"
+// if you want to connect a specified database named "dbName".

docs/examples/go/go.mod

+module goexample
+
+go 1.17
+
+require github.com/taosdata/driver-go/v3 3.0
+

docs/examples/go/insert/json/main.go

+package main
+
+import (
+	"log"
+
+	"github.com/taosdata/driver-go/v3/af"
+)
+
+func prepareDatabase(conn *af.Connector) {
+	_, err := conn.Exec("CREATE DATABASE test")
+	if err != nil {
+		panic(err)
+	}
+	_, err = conn.Exec("USE test")
+	if err != nil {
+		panic(err)
+	}
+}
+
+func main() {
+	conn, err := af.Open("localhost", "root", "taosdata", "", 6030)
+	if err != nil {
+		log.Fatalln("fail to connect, err:", err)
+	}
+	defer conn.Close()
+	prepareDatabase(conn)
+
+	payload := `[{"metric": "meters.current", "timestamp": 1648432611249, "value": 10.3, "tags": {"location": "California.SanFrancisco", "groupid": 2}},
+				{"metric": "meters.voltage", "timestamp": 1648432611249, "value": 219, "tags": {"location": "California.LosAngeles", "groupid": 1}},
+				{"metric": "meters.current", "timestamp": 1648432611250, "value": 12.6, "tags": {"location": "California.SanFrancisco", "groupid": 2}},
+				{"metric": "meters.voltage", "timestamp": 1648432611250, "value": 221, "tags": {"location": "California.LosAngeles", "groupid": 1}}]`
+
+	err = conn.OpenTSDBInsertJsonPayload(payload)
+	if err != nil {
+		log.Fatalln("insert error:", err)
+	}
+}

docs/examples/go/insert/line/main.go

+package main
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/taosdata/driver-go/v3/af"
+)
+
+func prepareDatabase(conn *af.Connector) {
+	_, err := conn.Exec("CREATE DATABASE test")
+	if err != nil {
+		panic(err)
+	}
+	_, err = conn.Exec("USE test")
+	if err != nil {
+		panic(err)
+	}
+}
+
+func main() {
+	conn, err := af.Open("localhost", "root", "taosdata", "", 6030)
+	if err != nil {
+		fmt.Println("fail to connect, err:", err)
+	}
+	defer conn.Close()
+	prepareDatabase(conn)
+	var lines = []string{
+		"meters,location=California.LosAngeles,groupid=2 current=11.8,voltage=221,phase=0.28 1648432611249",
+		"meters,location=California.LosAngeles,groupid=2 current=13.4,voltage=223,phase=0.29 1648432611250",
+		"meters,location=California.LosAngeles,groupid=3 current=10.8,voltage=223,phase=0.29 1648432611249",
+		"meters,location=California.LosAngeles,groupid=3 current=11.3,voltage=221,phase=0.35 1648432611250",
+	}
+
+	err = conn.InfluxDBInsertLines(lines, "ms")
+	if err != nil {
+		log.Fatalln("insert error:", err)
+	}
+}

docs/examples/go/insert/sql/main.go

+package main
+
+import (
+	"database/sql"
+	"fmt"
+	"log"
+
+	_ "github.com/taosdata/driver-go/v3/taosRestful"
+)
+
+func createStable(taos *sql.DB) {
+	_, err := taos.Exec("CREATE DATABASE power")
+	if err != nil {
+		log.Fatalln("failed to create database, err:", err)
+	}
+	_, err = taos.Exec("CREATE STABLE power.meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS (location BINARY(64), groupId INT)")
+	if err != nil {
+		log.Fatalln("failed to create stable, err:", err)
+	}
+}
+
+func insertData(taos *sql.DB) {
+	sql := `INSERT INTO power.d1001 USING power.meters TAGS('California.SanFrancisco', 2) VALUES ('2018-10-03 14:38:05.000', 10.30000, 219, 0.31000) ('2018-10-03 14:38:15.000', 12.60000, 218, 0.33000) ('2018-10-03 14:38:16.800', 12.30000, 221, 0.31000)
+	power.d1002 USING power.meters TAGS('California.SanFrancisco', 3) VALUES ('2018-10-03 14:38:16.650', 10.30000, 218, 0.25000)
+	power.d1003 USING power.meters TAGS('California.LosAngeles', 2) VALUES ('2018-10-03 14:38:05.500', 11.80000, 221, 0.28000) ('2018-10-03 14:38:16.600', 13.40000, 223, 0.29000)
+	power.d1004 USING power.meters TAGS('California.LosAngeles', 3) VALUES ('2018-10-03 14:38:05.000', 10.80000, 223, 0.29000) ('2018-10-03 14:38:06.500', 11.50000, 221, 0.35000)`
+	result, err := taos.Exec(sql)
+	if err != nil {
+		log.Fatalln("failed to insert, err:", err)
+	}
+	rowsAffected, err := result.RowsAffected()
+	if err != nil {
+		log.Fatalln("failed to get affected rows, err:", err)
+	}
+	fmt.Println("RowsAffected", rowsAffected)
+}
+
+func main() {
+	var taosDSN = "root:taosdata@http(localhost:6041)/"
+	taos, err := sql.Open("taosRestful", taosDSN)
+	if err != nil {
+		log.Fatalln("failed to connect TDengine, err:", err)
+	}
+	defer taos.Close()
+	createStable(taos)
+	insertData(taos)
+}

docs/examples/go/insert/stmt/main.go

+package main
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/taosdata/driver-go/v3/af"
+	"github.com/taosdata/driver-go/v3/common"
+	"github.com/taosdata/driver-go/v3/common/param"
+)
+
+func checkErr(err error, prompt string) {
+	if err != nil {
+		fmt.Printf("%s\n", prompt)
+		panic(err)
+	}
+}
+
+func prepareStable(conn *af.Connector) {
+	_, err := conn.Exec("CREATE DATABASE power")
+	checkErr(err, "failed to create database")
+	_, err = conn.Exec("CREATE STABLE power.meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS (location BINARY(64), groupId INT)")
+	checkErr(err, "failed to create stable")
+	_, err = conn.Exec("USE power")
+	checkErr(err, "failed to change database")
+}
+
+func main() {
+	conn, err := af.Open("localhost", "root", "taosdata", "", 6030)
+	checkErr(err, "fail to connect")
+	defer conn.Close()
+	prepareStable(conn)
+	// create stmt
+	stmt := conn.InsertStmt()
+	defer stmt.Close()
+	err = stmt.Prepare("INSERT INTO ? USING meters TAGS(?, ?) VALUES(?, ?, ?, ?)")
+	checkErr(err, "failed to create prepare statement")
+
+	// bind table name and tags
+	tagParams := param.NewParam(2).AddBinary([]byte("California.SanFrancisco")).AddInt(2)
+	err = stmt.SetTableNameWithTags("d1001", tagParams)
+	checkErr(err, "failed to execute SetTableNameWithTags")
+
+	// specify ColumnType
+	var bindType *param.ColumnType = param.NewColumnType(4).AddTimestamp().AddFloat().AddInt().AddFloat()
+
+	// bind values. note: can only bind one row each time.
+	valueParams := []*param.Param{
+		param.NewParam(1).AddTimestamp(time.Unix(1648432611, 249300000), common.PrecisionMilliSecond),
+		param.NewParam(1).AddFloat(10.3),
+		param.NewParam(1).AddInt(219),
+		param.NewParam(1).AddFloat(0.31),
+	}
+	err = stmt.BindParam(valueParams, bindType)
+	checkErr(err, "BindParam error")
+	err = stmt.AddBatch()
+	checkErr(err, "AddBatch error")
+
+	// bind one more row
+	valueParams = []*param.Param{
+		param.NewParam(1).AddTimestamp(time.Unix(1648432611, 749300000), common.PrecisionMilliSecond),
+		param.NewParam(1).AddFloat(12.6),
+		param.NewParam(1).AddInt(218),
+		param.NewParam(1).AddFloat(0.33),
+	}
+	err = stmt.BindParam(valueParams, bindType)
+	checkErr(err, "BindParam error")
+	err = stmt.AddBatch()
+	checkErr(err, "AddBatch error")
+	// execute
+	err = stmt.Execute()
+	checkErr(err, "Execute batch error")
+}

docs/examples/go/insert/telnet/main.go

+package main
+
+import (
+	"log"
+
+	"github.com/taosdata/driver-go/v3/af"
+)
+
+func prepareDatabase(conn *af.Connector) {
+	_, err := conn.Exec("CREATE DATABASE test")
+	if err != nil {
+		panic(err)
+	}
+	_, err = conn.Exec("USE test")
+	if err != nil {
+		panic(err)
+	}
+}
+
+func main() {
+	conn, err := af.Open("localhost", "root", "taosdata", "", 6030)
+	if err != nil {
+		log.Fatalln("fail to connect, err:", err)
+	}
+	defer conn.Close()
+	prepareDatabase(conn)
+	var lines = []string{
+		"meters.current 1648432611249 10.3 location=California.SanFrancisco groupid=2",
+		"meters.current 1648432611250 12.6 location=California.SanFrancisco groupid=2",
+		"meters.current 1648432611249 10.8 location=California.LosAngeles groupid=3",
+		"meters.current 1648432611250 11.3 location=California.LosAngeles groupid=3",
+		"meters.voltage 1648432611249 219 location=California.SanFrancisco groupid=2",
+		"meters.voltage 1648432611250 218 location=California.SanFrancisco groupid=2",
+		"meters.voltage 1648432611249 221 location=California.LosAngeles groupid=3",
+		"meters.voltage 1648432611250 217 location=California.LosAngeles groupid=3",
+	}
+
+	err = conn.OpenTSDBInsertTelnetLines(lines)
+	if err != nil {
+		log.Fatalln("insert error:", err)
+	}
+}

docs/examples/go/query/async/main.go

+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println("hello world!")
+}

docs/examples/go/query/sync/main.go

+package main
+
+import (
+	"database/sql"
+	"log"
+	"time"
+
+	_ "github.com/taosdata/driver-go/v3/taosRestful"
+)
+
+func main() {
+	var taosDSN = "root:taosdata@http(localhost:6041)/power"
+	taos, err := sql.Open("taosRestful", taosDSN)
+	if err != nil {
+		log.Fatalln("failed to connect TDengine, err:", err)
+	}
+	defer taos.Close()
+	rows, err := taos.Query("SELECT ts, current FROM meters LIMIT 2")
+	if err != nil {
+		log.Fatalln("failed to select from table, err:", err)
+	}
+
+	defer rows.Close()
+	for rows.Next() {
+		var r struct {
+			ts      time.Time
+			current float32
+		}
+		err := rows.Scan(&r.ts, &r.current)
+		if err != nil {
+			log.Fatalln("scan error:\n", err)
+			return
+		}
+		log.Println(r.ts, r.current)
+	}
+}

docs/examples/go/rest/opentsdbjson/main.go

+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"time"
+)
+
+type Tags struct {
+	Location string `json:"location"`
+	Groupid  int32  `json:"groupid"`
+}
+
+type Metric struct {
+	Metric    string `json:"metric"`
+	Timestamp int64  `json:"timestamp"`
+	Value     int32  `json:"value"`
+	Tags      Tags   `json:"tags"`
+}
+
+func main() {
+	client := http.Client{}
+	for i := 0; i < 10; i++ {
+		metric := Metric{"voltage", time.Now().UnixMilli(), 1, Tags{"A", 1}}
+		json, err := json.Marshal(metric)
+		if err != nil {
+			panic(err)
+		}
+		req, err := http.NewRequest("POST", "http://localhost:6041/opentsdb/v1/put/json/rest_go", bytes.NewBuffer(json))
+		if err != nil {
+			panic(err)
+		}
+		req.Header.Set("Content-Type", "application/json")
+		req.Header.Set("Authorization", "Basic cm9vdDp0YW9zZGF0YQ==")
+		resp, err := client.Do(req)
+		if err != nil {
+			panic(err)
+		}
+		fmt.Printf("%v\n", resp)
+		time.Sleep(time.Second)
+
+	}
+}

docs/examples/go/sub/main.go

+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"time"
+
+	"github.com/taosdata/driver-go/v3/af"
+	"github.com/taosdata/driver-go/v3/af/tmq"
+	"github.com/taosdata/driver-go/v3/common"
+	"github.com/taosdata/driver-go/v3/errors"
+	"github.com/taosdata/driver-go/v3/wrapper"
+)
+
+func main() {
+	db, err := af.Open("", "root", "taosdata", "", 0)
+	if err != nil {
+		panic(err)
+	}
+	defer db.Close()
+	_, err = db.Exec("create database if not exists example_tmq")
+	if err != nil {
+		panic(err)
+	}
+	_, err = db.Exec("create topic if not exists example_tmq_topic with meta as DATABASE example_tmq")
+	if err != nil {
+		panic(err)
+	}
+	config := tmq.NewConfig()
+	defer config.Destroy()
+	err = config.SetGroupID("test")
+	if err != nil {
+		panic(err)
+	}
+	err = config.SetAutoOffsetReset("earliest")
+	if err != nil {
+		panic(err)
+	}
+	err = config.SetConnectIP("127.0.0.1")
+	if err != nil {
+		panic(err)
+	}
+	err = config.SetConnectUser("root")
+	if err != nil {
+		panic(err)
+	}
+	err = config.SetConnectPass("taosdata")
+	if err != nil {
+		panic(err)
+	}
+	err = config.SetConnectPort("6030")
+	if err != nil {
+		panic(err)
+	}
+	err = config.SetMsgWithTableName(true)
+	if err != nil {
+		panic(err)
+	}
+	err = config.EnableHeartBeat()
+	if err != nil {
+		panic(err)
+	}
+	err = config.EnableAutoCommit(func(result *wrapper.TMQCommitCallbackResult) {
+		if result.ErrCode != 0 {
+			errStr := wrapper.TMQErr2Str(result.ErrCode)
+			err := errors.NewError(int(result.ErrCode), errStr)
+			panic(err)
+		}
+	})
+	if err != nil {
+		panic(err)
+	}
+	consumer, err := tmq.NewConsumer(config)
+	if err != nil {
+		panic(err)
+	}
+	err = consumer.Subscribe([]string{"example_tmq_topic"})
+	if err != nil {
+		panic(err)
+	}
+	_, err = db.Exec("create table example_tmq.t1 (ts timestamp,v int)")
+	if err != nil {
+		panic(err)
+	}
+	for {
+		result, err := consumer.Poll(time.Second)
+		if err != nil {
+			panic(err)
+		}
+		if result.Type != common.TMQ_RES_TABLE_META {
+			panic("want message type 2 got " + strconv.Itoa(int(result.Type)))
+		}
+		data, _ := json.Marshal(result.Meta)
+		fmt.Println(string(data))
+		consumer.Commit(context.Background(), result.Message)
+		consumer.FreeMessage(result.Message)
+		break
+	}
+	_, err = db.Exec("insert into example_tmq.t1 values(now,1)")
+	if err != nil {
+		panic(err)
+	}
+	for {
+		result, err := consumer.Poll(time.Second)
+		if err != nil {
+			panic(err)
+		}
+		if result.Type != common.TMQ_RES_DATA {
+			panic("want message type 1 got " + strconv.Itoa(int(result.Type)))
+		}
+		data, _ := json.Marshal(result.Data)
+		fmt.Println(string(data))
+		consumer.Commit(context.Background(), result.Message)
+		consumer.FreeMessage(result.Message)
+		break
+	}
+	consumer.Close()
+}

docs/examples/java/pom.xml

@@ -21,7 +21,7 @@
     <dependency>
       <groupId>com.taosdata.jdbc</groupId>
       <artifactId>taos-jdbcdriver</artifactId>
-      <version>2.0.40</version>
+      <version>3.0.0</version>
     </dependency>
 <!--    ANCHOR_END: dep-->
     <dependency>

docs/examples/java/src/main/java/com/taos/example/JNIConnectExample.java

+package com.taos.example;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.util.Properties;
+
+import com.taosdata.jdbc.TSDBDriver;
+
+public class JNIConnectExample {
+    public static void main(String[] args) throws SQLException {
+        String jdbcUrl = "jdbc:TAOS://localhost:6030?user=root&password=taosdata";
+        Properties connProps = new Properties();
+        connProps.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
+        connProps.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8");
+        connProps.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
+        Connection conn = DriverManager.getConnection(jdbcUrl, connProps);
+        System.out.println("Connected");
+        conn.close();
+    }
+}
+
+// use
+// String jdbcUrl = "jdbc:TAOS://localhost:6030/dbName?user=root&password=taosdata";
+// if you want to connect a specified database named "dbName".
\ No newline at end of file

docs/examples/java/src/main/java/com/taos/example/JSONProtocolExample.java

+package com.taos.example;
+
+import com.taosdata.jdbc.SchemalessWriter;
+import com.taosdata.jdbc.enums.SchemalessProtocolType;
+import com.taosdata.jdbc.enums.SchemalessTimestampType;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+public class JSONProtocolExample {
+    private static Connection getConnection() throws SQLException {
+        String jdbcUrl = "jdbc:TAOS://localhost:6030?user=root&password=taosdata";
+        return DriverManager.getConnection(jdbcUrl);
+    }
+
+    private static void createDatabase(Connection conn) throws SQLException {
+        try (Statement stmt = conn.createStatement()) {
+            stmt.execute("CREATE DATABASE IF NOT EXISTS test");
+            stmt.execute("USE test");
+        }
+    }
+
+    private static String getJSONData() {
+        return "[{\"metric\": \"meters.current\", \"timestamp\": 1648432611249, \"value\": 10.3, \"tags\": {\"location\": \"California.SanFrancisco\", \"groupid\": 2}}," +
+                " {\"metric\": \"meters.voltage\", \"timestamp\": 1648432611249, \"value\": 219, \"tags\": {\"location\": \"California.LosAngeles\", \"groupid\": 1}}, " +
+                "{\"metric\": \"meters.current\", \"timestamp\": 1648432611250, \"value\": 12.6, \"tags\": {\"location\": \"California.SanFrancisco\", \"groupid\": 2}}," +
+                " {\"metric\": \"meters.voltage\", \"timestamp\": 1648432611250, \"value\": 221, \"tags\": {\"location\": \"California.LosAngeles\", \"groupid\": 1}}]";
+    }
+
+    public static void main(String[] args) throws SQLException {
+        try (Connection conn = getConnection()) {
+            createDatabase(conn);
+            SchemalessWriter writer = new SchemalessWriter(conn);
+            String jsonData = getJSONData();
+            writer.write(jsonData, SchemalessProtocolType.JSON, SchemalessTimestampType.NOT_CONFIGURED);
+        }
+    }
+}

docs/examples/java/src/main/java/com/taos/example/LineProtocolExample.java

+package com.taos.example;
+
+import com.taosdata.jdbc.SchemalessWriter;
+import com.taosdata.jdbc.enums.SchemalessProtocolType;
+import com.taosdata.jdbc.enums.SchemalessTimestampType;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+public class LineProtocolExample {
+    // format: measurement,tag_set field_set timestamp
+    private static String[] lines = {
+            "meters,location=California.LosAngeles,groupid=2 current=11.8,voltage=221,phase=0.28 1648432611249000", // micro
+                                                                                                              // seconds
+            "meters,location=California.LosAngeles,groupid=2 current=13.4,voltage=223,phase=0.29 1648432611249500",
+            "meters,location=California.LosAngeles,groupid=3 current=10.8,voltage=223,phase=0.29 1648432611249300",
+            "meters,location=California.LosAngeles,groupid=3 current=11.3,voltage=221,phase=0.35 1648432611249800",
+    };
+
+    private static Connection getConnection() throws SQLException {
+        String jdbcUrl = "jdbc:TAOS://localhost:6030?user=root&password=taosdata";
+        return DriverManager.getConnection(jdbcUrl);
+    }
+
+    private static void createDatabase(Connection conn) throws SQLException {
+        try (Statement stmt = conn.createStatement()) {
+            // the default precision is ms (millisecond), but we use us(microsecond) here.
+            stmt.execute("CREATE DATABASE IF NOT EXISTS test PRECISION 'us'");
+            stmt.execute("USE test");
+        }
+    }
+
+    public static void main(String[] args) throws SQLException {
+        try (Connection conn = getConnection()) {
+            createDatabase(conn);
+            SchemalessWriter writer = new SchemalessWriter(conn);
+            writer.write(lines, SchemalessProtocolType.LINE, SchemalessTimestampType.MICRO_SECONDS);
+        }
+    }
+}

docs/examples/java/src/main/java/com/taos/example/Meters.java

+package com.taos.example;
+
+import java.sql.Timestamp;
+
+public class Meters {
+    private Timestamp ts;
+    private float current;
+    private int voltage;
+    private int groupid;
+    private String location;
+
+    public Timestamp getTs() {
+        return ts;
+    }
+
+    public void setTs(Timestamp ts) {
+        this.ts = ts;
+    }
+
+    public float getCurrent() {
+        return current;
+    }
+
+    public void setCurrent(float current) {
+        this.current = current;
+    }
+
+    public int getVoltage() {
+        return voltage;
+    }
+
+    public void setVoltage(int voltage) {
+        this.voltage = voltage;
+    }
+
+    public int getGroupid() {
+        return groupid;
+    }
+
+    public void setGroupid(int groupid) {
+        this.groupid = groupid;
+    }
+
+    public String getLocation() {
+        return location;
+    }
+
+    public void setLocation(String location) {
+        this.location = location;
+    }
+
+    @Override
+    public String toString() {
+        return "Meters{" +
+                "ts=" + ts +
+                ", current=" + current +
+                ", voltage=" + voltage +
+                ", groupid=" + groupid +
+                ", location='" + location + '\'' +
+                '}';
+    }
+}

docs/examples/java/src/main/java/com/taos/example/MetersDeserializer.java

+package com.taos.example;
+
+import com.taosdata.jdbc.tmq.ReferenceDeserializer;
+
+public class MetersDeserializer extends ReferenceDeserializer<Meters> {
+}
\ No newline at end of file

docs/examples/java/src/main/java/com/taos/example/RESTConnectExample.java

+package com.taos.example;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+
+public class RESTConnectExample {
+    // ANCHOR: main
+    public static void main(String[] args) throws SQLException {
+        String jdbcUrl = "jdbc:TAOS-RS://localhost:6041?user=root&password=taosdata";
+        Connection conn = DriverManager.getConnection(jdbcUrl);
+        System.out.println("Connected");
+        conn.close();
+    }
+    // ANCHOR_END: main
+}
\ No newline at end of file

docs/examples/java/src/main/java/com/taos/example/RestInsertExample.java

+package com.taos.example;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.Arrays;
+import java.util.List;
+
+
+public class RestInsertExample {
+    private static Connection getConnection() throws SQLException {
+        String jdbcUrl = "jdbc:TAOS-RS://localhost:6041?user=root&password=taosdata";
+        return DriverManager.getConnection(jdbcUrl);
+    }
+
+    private static List<String> getRawData() {
+        return Arrays.asList(
+                "d1001,2018-10-03 14:38:05.000,10.30000,219,0.31000,California.SanFrancisco,2",
+                "d1001,2018-10-03 14:38:15.000,12.60000,218,0.33000,California.SanFrancisco,2",
+                "d1001,2018-10-03 14:38:16.800,12.30000,221,0.31000,California.SanFrancisco,2",
+                "d1002,2018-10-03 14:38:16.650,10.30000,218,0.25000,California.SanFrancisco,3",
+                "d1003,2018-10-03 14:38:05.500,11.80000,221,0.28000,California.LosAngeles,2",
+                "d1003,2018-10-03 14:38:16.600,13.40000,223,0.29000,California.LosAngeles,2",
+                "d1004,2018-10-03 14:38:05.000,10.80000,223,0.29000,California.LosAngeles,3",
+                "d1004,2018-10-03 14:38:06.500,11.50000,221,0.35000,California.LosAngeles,3"
+        );
+    }
+
+
+    /**
+     * The generated SQL is:
+     * INSERT INTO power.d1001 USING power.meters TAGS(California.SanFrancisco, 2) VALUES('2018-10-03 14:38:05.000',10.30000,219,0.31000)
+     * power.d1001 USING power.meters TAGS(California.SanFrancisco, 2) VALUES('2018-10-03 14:38:15.000',12.60000,218,0.33000)
+     * power.d1001 USING power.meters TAGS(California.SanFrancisco, 2) VALUES('2018-10-03 14:38:16.800',12.30000,221,0.31000)
+     * power.d1002 USING power.meters TAGS(California.SanFrancisco, 3) VALUES('2018-10-03 14:38:16.650',10.30000,218,0.25000)
+     * power.d1003 USING power.meters TAGS(California.LosAngeles, 2) VALUES('2018-10-03 14:38:05.500',11.80000,221,0.28000)
+     * power.d1003 USING power.meters TAGS(California.LosAngeles, 2) VALUES('2018-10-03 14:38:16.600',13.40000,223,0.29000)
+     * power.d1004 USING power.meters TAGS(California.LosAngeles, 3) VALUES('2018-10-03 14:38:05.000',10.80000,223,0.29000)
+     * power.d1004 USING power.meters TAGS(California.LosAngeles, 3) VALUES('2018-10-03 14:38:06.500',11.50000,221,0.35000)
+     */
+    private static String getSQL() {
+        StringBuilder sb = new StringBuilder("INSERT INTO ");
+        for (String line : getRawData()) {
+            String[] ps = line.split(",");
+            sb.append("power." + ps[0]).append(" USING power.meters TAGS(")
+                    .append(ps[5]).append(", ") // tag: location
+                    .append(ps[6]) // tag: groupId
+                    .append(") VALUES(")
+                    .append('\'').append(ps[1]).append('\'').append(",") // ts
+                    .append(ps[2]).append(",") // current
+                    .append(ps[3]).append(",") // voltage
+                    .append(ps[4]).append(") "); // phase
+        }
+        return sb.toString();
+    }
+
+    public static void insertData() throws SQLException {
+        try (Connection conn = getConnection()) {
+            try (Statement stmt = conn.createStatement()) {
+                stmt.execute("CREATE DATABASE power KEEP 3650");
+                stmt.execute("CREATE STABLE power.meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) " +
+                        "TAGS (location BINARY(64), groupId INT)");
+                String sql = getSQL();
+                int rowCount = stmt.executeUpdate(sql);
+                System.out.println("rowCount=" + rowCount); // rowCount=8
+            }
+        }
+    }
+
+    public static void main(String[] args) throws SQLException {
+        insertData();
+    }
+}

docs/examples/java/src/main/java/com/taos/example/RestQueryExample.java

+package com.taos.example;
+
+import java.sql.*;
+
+public class RestQueryExample {
+    private static Connection getConnection() throws SQLException {
+        String jdbcUrl = "jdbc:TAOS-RS://localhost:6041/power?user=root&password=taosdata";
+        return DriverManager.getConnection(jdbcUrl);
+    }
+
+    private static void printRow(ResultSet rs) throws SQLException {
+        ResultSetMetaData meta = rs.getMetaData();
+        for (int i = 1; i <= meta.getColumnCount(); i++) {
+            String value = rs.getString(i);
+            System.out.print(value);
+            System.out.print("\t");
+        }
+        System.out.println();
+    }
+
+    private static void printColName(ResultSet rs) throws SQLException {
+        ResultSetMetaData meta = rs.getMetaData();
+        for (int i = 1; i <= meta.getColumnCount(); i++) {
+            String colLabel = meta.getColumnLabel(i);
+            System.out.print(colLabel);
+            System.out.print("\t");
+        }
+        System.out.println();
+    }
+
+    private static void processResult(ResultSet rs) throws SQLException {
+        printColName(rs);
+        while (rs.next()) {
+            printRow(rs);
+        }
+    }
+
+    private static void queryData() throws SQLException {
+        try (Connection conn = getConnection()) {
+            try (Statement stmt = conn.createStatement()) {
+                ResultSet rs = stmt.executeQuery("SELECT AVG(voltage) FROM meters GROUP BY location");
+                processResult(rs);
+            }
+        }
+    }
+
+    public static void main(String[] args) throws SQLException {
+        queryData();
+    }
+}
+
+// possible output:
+// avg(voltage)	location
+// 222.0	California.LosAngeles
+// 219.0	California.SanFrancisco

docs/examples/java/src/main/java/com/taos/example/StmtInsertExample.java

+package com.taos.example;
+
+import com.taosdata.jdbc.TSDBPreparedStatement;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.time.LocalDateTime;
+import java.time.ZoneOffset;
+import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class StmtInsertExample {
+    private static ArrayList<Long> tsToLongArray(String ts) {
+        ArrayList<Long> result = new ArrayList<>();
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS");
+        LocalDateTime localDateTime = LocalDateTime.parse(ts, formatter);
+        result.add(localDateTime.toInstant(ZoneOffset.of("+8")).toEpochMilli());
+        return result;
+    }
+
+    private static <T> ArrayList<T> toArray(T v) {
+        ArrayList<T> result = new ArrayList<>();
+        result.add(v);
+        return result;
+    }
+
+    private static List<String> getRawData() {
+        return Arrays.asList(
+                "d1001,2018-10-03 14:38:05.000,10.30000,219,0.31000,California.SanFrancisco,2",
+                "d1001,2018-10-03 14:38:15.000,12.60000,218,0.33000,California.SanFrancisco,2",
+                "d1001,2018-10-03 14:38:16.800,12.30000,221,0.31000,California.SanFrancisco,2",
+                "d1002,2018-10-03 14:38:16.650,10.30000,218,0.25000,California.SanFrancisco,3",
+                "d1003,2018-10-03 14:38:05.500,11.80000,221,0.28000,California.LosAngeles,2",
+                "d1003,2018-10-03 14:38:16.600,13.40000,223,0.29000,California.LosAngeles,2",
+                "d1004,2018-10-03 14:38:05.000,10.80000,223,0.29000,California.LosAngeles,3",
+                "d1004,2018-10-03 14:38:06.500,11.50000,221,0.35000,California.LosAngeles,3"
+        );
+    }
+
+    private static Connection getConnection() throws SQLException {
+        String jdbcUrl = "jdbc:TAOS://localhost:6030?user=root&password=taosdata";
+        return DriverManager.getConnection(jdbcUrl);
+    }
+
+    private static void createTable(Connection conn) throws SQLException {
+        try (Statement stmt = conn.createStatement()) {
+            stmt.execute("CREATE DATABASE power KEEP 3650");
+            stmt.executeUpdate("USE power");
+            stmt.execute("CREATE STABLE meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) " +
+                    "TAGS (location BINARY(64), groupId INT)");
+        }
+    }
+
+    private static void insertData() throws SQLException {
+        try (Connection conn = getConnection()) {
+            createTable(conn);
+            String psql = "INSERT INTO ? USING meters TAGS(?, ?) VALUES(?, ?, ?, ?)";
+            try (TSDBPreparedStatement pst = (TSDBPreparedStatement) conn.prepareStatement(psql)) {
+                for (String line : getRawData()) {
+                    String[] ps = line.split(",");
+                    // bind table name and tags
+                    pst.setTableName(ps[0]);
+                    pst.setTagString(0, ps[5]);
+                    pst.setTagInt(1, Integer.valueOf(ps[6]));
+                    // bind values
+                    pst.setTimestamp(0, tsToLongArray(ps[1])); //ps[1] looks like: 2018-10-03 14:38:05.000
+                    pst.setFloat(1, toArray(Float.valueOf(ps[2])));
+                    pst.setInt(2, toArray(Integer.valueOf(ps[3])));
+                    pst.setFloat(3, toArray(Float.valueOf(ps[4])));
+                    pst.columnDataAddBatch();
+                }
+                pst.columnDataExecuteBatch();
+            }
+        }
+    }
+
+    public static void main(String[] args) throws SQLException {
+        insertData();
+    }
+}

docs/examples/java/src/main/java/com/taos/example/SubscribeDemo.java

+package com.taos.example;
+
+import com.taosdata.jdbc.tmq.ConsumerRecords;
+import com.taosdata.jdbc.tmq.TMQConstants;
+import com.taosdata.jdbc.tmq.TaosConsumer;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.time.Duration;
+import java.util.Collections;
+import java.util.Properties;
+import java.util.Timer;
+import java.util.TimerTask;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class SubscribeDemo {
+    private static final String TOPIC = "tmq_topic";
+    private static final String DB_NAME = "meters";
+    private static final AtomicBoolean shutdown = new AtomicBoolean(false);
+
+    public static void main(String[] args) {
+        Timer timer = new Timer();
+        timer.schedule(new TimerTask() {
+            public void run() {
+                shutdown.set(true);
+            }
+        }, 3_000);
+        try {
+            // prepare
+            Class.forName("com.taosdata.jdbc.TSDBDriver");
+            String jdbcUrl = "jdbc:TAOS://127.0.0.1:6030/?user=root&password=taosdata";
+            Connection connection = DriverManager.getConnection(jdbcUrl);
+            try (Statement statement = connection.createStatement()) {
+                statement.executeUpdate("drop topic if exists " + TOPIC);
+                statement.executeUpdate("drop database if exists " + DB_NAME);
+                statement.executeUpdate("create database " + DB_NAME);
+                statement.executeUpdate("use " + DB_NAME);
+                statement.executeUpdate(
+                        "CREATE TABLE `meters` (`ts` TIMESTAMP, `current` FLOAT, `voltage` INT) TAGS (`groupid` INT, `location` BINARY(16))");
+                statement.executeUpdate("CREATE TABLE `d0` USING `meters` TAGS(0, 'Los Angles')");
+                statement.executeUpdate("INSERT INTO `d0` values(now - 10s, 0.32, 116)");
+                statement.executeUpdate("INSERT INTO `d0` values(now - 8s, NULL, NULL)");
+                statement.executeUpdate(
+                        "INSERT INTO `d1` USING `meters` TAGS(1, 'San Francisco') values(now - 9s, 10.1, 119)");
+                statement.executeUpdate(
+                        "INSERT INTO `d1` values (now-8s, 10, 120) (now - 6s, 10, 119) (now - 4s, 11.2, 118)");
+                // create topic
+                statement.executeUpdate("create topic " + TOPIC + " as select * from meters");
+            }
+
+            // create consumer
+            Properties properties = new Properties();
+            properties.setProperty(TMQConstants.BOOTSTRAP_SERVERS, "127.0.0.1:6030");
+            properties.setProperty(TMQConstants.MSG_WITH_TABLE_NAME, "true");
+            properties.setProperty(TMQConstants.ENABLE_AUTO_COMMIT, "true");
+            properties.setProperty(TMQConstants.GROUP_ID, "test");
+            properties.setProperty(TMQConstants.VALUE_DESERIALIZER,
+                    "com.taosdata.jdbc.MetersDeserializer");
+
+            // poll data
+            try (TaosConsumer<Meters> consumer = new TaosConsumer<>(properties)) {
+                consumer.subscribe(Collections.singletonList(TOPIC));
+                while (!shutdown.get()) {
+                    ConsumerRecords<Meters> meters = consumer.poll(Duration.ofMillis(100));
+                    for (Meters meter : meters) {
+                        System.out.println(meter);
+                    }
+                }
+                consumer.unsubscribe();
+            }
+        } catch (ClassNotFoundException | SQLException e) {
+            e.printStackTrace();
+        }
+        timer.cancel();
+    }
+}
\ No newline at end of file

docs/examples/java/src/main/java/com/taos/example/TelnetLineProtocolExample.java

+package com.taos.example;
+
+import com.taosdata.jdbc.SchemalessWriter;
+import com.taosdata.jdbc.enums.SchemalessProtocolType;
+import com.taosdata.jdbc.enums.SchemalessTimestampType;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+public class TelnetLineProtocolExample {
+    // format: <metric> <timestamp> <value> <tagk_1>=<tagv_1>[ <tagk_n>=<tagv_n>]
+    private static String[] lines = { "meters.current 1648432611249 10.3 location=California.SanFrancisco groupid=2",
+            "meters.current 1648432611250 12.6 location=California.SanFrancisco groupid=2",
+            "meters.current 1648432611249 10.8 location=California.LosAngeles groupid=3",
+            "meters.current 1648432611250 11.3 location=California.LosAngeles groupid=3",
+            "meters.voltage 1648432611249 219 location=California.SanFrancisco groupid=2",
+            "meters.voltage 1648432611250 218 location=California.SanFrancisco groupid=2",
+            "meters.voltage 1648432611249 221 location=California.LosAngeles groupid=3",
+            "meters.voltage 1648432611250 217 location=California.LosAngeles groupid=3",
+    };
+
+    private static Connection getConnection() throws SQLException {
+        String jdbcUrl = "jdbc:TAOS://localhost:6030?user=root&password=taosdata";
+        return DriverManager.getConnection(jdbcUrl);
+    }
+
+    private static void createDatabase(Connection conn) throws SQLException {
+        try (Statement stmt = conn.createStatement()) {
+            // the default precision is ms (microsecond), but we use us(microsecond) here.
+            stmt.execute("CREATE DATABASE IF NOT EXISTS test precision 'us'");
+            stmt.execute("USE test");
+        }
+    }
+
+    public static void main(String[] args) throws SQLException {
+        try (Connection conn = getConnection()) {
+            createDatabase(conn);
+            SchemalessWriter writer = new SchemalessWriter(conn);
+            writer.write(lines, SchemalessProtocolType.TELNET, SchemalessTimestampType.NOT_CONFIGURED);
+        }
+    }
+
+}

docs/examples/java/src/main/java/com/taos/example/WSConnectExample.java

+package com.taos.example;
+
+import com.taosdata.jdbc.TSDBDriver;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.util.Properties;
+
+public class WSConnectExample {
+    // ANCHOR: main
+    public static void main(String[] args) throws SQLException {
+        String jdbcUrl = "jdbc:TAOS-RS://localhost:6041?user=root&password=taosdata";
+        Properties connProps = new Properties();
+        connProps.setProperty(TSDBDriver.PROPERTY_KEY_BATCH_LOAD, "true");
+        Connection conn = DriverManager.getConnection(jdbcUrl, connProps);
+        System.out.println("Connected");
+        conn.close();
+    }
+    // ANCHOR_END: main
+}

docs/examples/java/src/test/java/com/taos/test/TestAll.java

 package com.taos.test;
 
-import com.taos.example.CloudTutorial;
-import com.taos.example.ConnectCloudExample;
+import com.taos.example.*;
+import org.junit.FixMethodOrder;
 import org.junit.Test;
 
-import java.sql.SQLException;
+import java.sql.*;
 
+@FixMethodOrder
 public class TestAll {
+    private String[] args = new String[]{};
+
+    public void dropDB(String dbName) throws SQLException {
+        String jdbcUrl = "jdbc:TAOS://localhost:6030?user=root&password=taosdata";
+        try (Connection conn = DriverManager.getConnection(jdbcUrl)) {
+            try (Statement stmt = conn.createStatement()) {
+                stmt.execute("drop database if exists " + dbName);
+            }
+        }
+    }
+
+    public void insertData() throws SQLException {
+        String jdbcUrl = "jdbc:TAOS://localhost:6030?user=root&password=taosdata";
+        try (Connection conn = DriverManager.getConnection(jdbcUrl)) {
+            try (Statement stmt = conn.createStatement()) {
+                String sql = "INSERT INTO power.d1001 USING power.meters TAGS(California.SanFrancisco, 2) VALUES('2018-10-03 14:38:05.000',10.30000,219,0.31000)\n" +
+                        "                        power.d1001 USING power.meters TAGS(California.SanFrancisco, 2) VALUES('2018-10-03 15:38:15.000',12.60000,218,0.33000)\n" +
+                        "                        power.d1001 USING power.meters TAGS(California.SanFrancisco, 2) VALUES('2018-10-03 15:38:16.800',12.30000,221,0.31000)\n" +
+                        "                        power.d1002 USING power.meters TAGS(California.SanFrancisco, 3) VALUES('2018-10-03 15:38:16.650',10.30000,218,0.25000)\n" +
+                        "                        power.d1003 USING power.meters TAGS(California.LosAngeles, 2) VALUES('2018-10-03 15:38:05.500',11.80000,221,0.28000)\n" +
+                        "                        power.d1003 USING power.meters TAGS(California.LosAngeles, 2) VALUES('2018-10-03 15:38:16.600',13.40000,223,0.29000)\n" +
+                        "                        power.d1004 USING power.meters TAGS(California.LosAngeles, 3) VALUES('2018-10-03 15:38:05.000',10.80000,223,0.29000)\n" +
+                        "                        power.d1004 USING power.meters TAGS(California.LosAngeles, 3) VALUES('2018-10-03 15:38:06.000',10.80000,223,0.29000)\n" +
+                        "                        power.d1004 USING power.meters TAGS(California.LosAngeles, 3) VALUES('2018-10-03 15:38:07.000',10.80000,223,0.29000)\n" +
+                        "                        power.d1004 USING power.meters TAGS(California.LosAngeles, 3) VALUES('2018-10-03 15:38:08.500',11.50000,221,0.35000)";
+
+                stmt.execute(sql);
+            }
+        }
+    }
+
+    @Test
+    public void testJNIConnect() throws SQLException {
+        JNIConnectExample.main(args);
+    }
 
     @Test
-    public void testConnectCloudExample() throws SQLException {
-        ConnectCloudExample.main(new String[]{});
+    public void testRestConnect() throws SQLException {
+        RESTConnectExample.main(args);
     }
 
-//    @Test
-//    public void testCloudTutorial() throws SQLException {
-//        CloudTutorial.main(new String[]{});
-//    }
+    @Test
+    public void testRestInsert() throws SQLException {
+        dropDB("power");
+        RestInsertExample.main(args);
+        RestQueryExample.main(args);
+    }
+
+    @Test
+    public void testStmtInsert() throws SQLException {
+        dropDB("power");
+        StmtInsertExample.main(args);
+    }
+
+    @Test
+    public void testSubscribe() {
+
+        Thread thread = new Thread(() -> {
+            try {
+                Thread.sleep(1000);
+                insertData();
+            } catch (SQLException e) {
+                e.printStackTrace();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        });
+        thread.start();
+        SubscribeDemo.main(args);
+    }
+
+    @Test
+    public void testSchemaless() throws SQLException {
+        LineProtocolExample.main(args);
+        TelnetLineProtocolExample.main(args);
+        // for json protocol, tags may be double type. but for telnet protocol tag must be nchar type.
+        // To avoid type mismatch, we delete database test.
+        dropDB("test");
+        JSONProtocolExample.main(args);
+    }
 }

docs/examples/node/nativeexample/async_query_example.js

+const taos = require("@tdengine/client");
+const conn = taos.connect({ host: "localhost", database: "power" });
+const cursor = conn.cursor();
+
+function queryExample() {
+  cursor
+    .query("SELECT ts, current FROM meters LIMIT 2")
+    .execute_a()
+    .then((result) => {
+      result.pretty();
+    });
+}
+
+try {
+  queryExample();
+} finally {
+  setTimeout(() => {
+    conn.close();
+  }, 2000);
+}

docs/examples/node/nativeexample/connect.js

+//A cursor also needs to be initialized in order to interact with TDengine from Node.js.
+const taos = require("@tdengine/client");
+var conn = taos.connect({
+  host: "127.0.0.1",
+  user: "root",
+  password: "taosdata",
+  config: "/etc/taos",
+  port: 0,
+});
+var cursor = conn.cursor(); // Initializing a new cursor
+
+//Close a connection
+conn.close();
\ No newline at end of file

docs/examples/node/nativeexample/influxdb_line_example.js

+const taos = require("@tdengine/client");
+
+const conn = taos.connect({
+  host: "localhost",
+});
+
+const cursor = conn.cursor();
+
+function createDatabase() {
+  cursor.execute("CREATE DATABASE test");
+  cursor.execute("USE test");
+}
+
+function insertData() {
+  const lines = [
+    "meters,location=California.LosAngeles,groupid=2 current=11.8,voltage=221,phase=0.28 1648432611249",
+    "meters,location=California.LosAngeles,groupid=2 current=13.4,voltage=223,phase=0.29 1648432611250",
+    "meters,location=California.LosAngeles,groupid=3 current=10.8,voltage=223,phase=0.29 1648432611249",
+    "meters,location=California.LosAngeles,groupid=3 current=11.3,voltage=221,phase=0.35 1648432611250",
+  ];
+  cursor.schemalessInsert(
+    lines,
+    taos.SCHEMALESS_PROTOCOL.TSDB_SML_LINE_PROTOCOL,
+    taos.SCHEMALESS_PRECISION.TSDB_SML_TIMESTAMP_MILLI_SECONDS
+  );
+}
+
+try {
+  createDatabase();
+  insertData();
+} finally {
+  cursor.close(); 
+  conn.close();
+}

docs/examples/node/nativeexample/insert_example.js

+const taos = require("@tdengine/client");
+
+const conn = taos.connect({
+  host: "localhost",
+});
+
+const cursor = conn.cursor();
+try {
+  cursor.execute("CREATE DATABASE power");
+  cursor.execute("USE power");
+  cursor.execute(
+    "CREATE STABLE meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS (location BINARY(64), groupId INT)"
+  );
+  var sql = `INSERT INTO power.d1001 USING power.meters TAGS('California.SanFrancisco', 2) VALUES ('2018-10-03 14:38:05.000', 10.30000, 219, 0.31000) ('2018-10-03 14:38:15.000', 12.60000, 218, 0.33000) ('2018-10-03 14:38:16.800', 12.30000, 221, 0.31000)
+power.d1002 USING power.meters TAGS('California.SanFrancisco', 3) VALUES ('2018-10-03 14:38:16.650', 10.30000, 218, 0.25000)
+power.d1003 USING power.meters TAGS('California.LosAngeles', 2) VALUES ('2018-10-03 14:38:05.500', 11.80000, 221, 0.28000) ('2018-10-03 14:38:16.600', 13.40000, 223, 0.29000)
+power.d1004 USING power.meters TAGS('California.LosAngeles', 3) VALUES ('2018-10-03 14:38:05.000', 10.80000, 223, 0.29000) ('2018-10-03 14:38:06.500', 11.50000, 221, 0.35000)`;
+  cursor.execute(sql,{'quiet':false});
+} finally {
+  cursor.close();
+  conn.close();
+}
+
+// run with: node insert_example.js
+// output:
+// Successfully connected to TDengine
+// Query OK, 0 row(s) affected (0.00509570s)
+// Query OK, 0 row(s) affected (0.00130880s)
+// Query OK, 0 row(s) affected (0.00467900s)
+// Query OK, 8 row(s) affected (0.04043550s)
+// Connection is closed

docs/examples/node/nativeexample/multi_bind_example.js

+const taos = require("@tdengine/client");
+
+const conn = taos.connect({
+  host: "localhost",
+});
+
+const cursor = conn.cursor();
+
+function prepareSTable() {
+  cursor.execute("CREATE DATABASE power");
+  cursor.execute("USE power");
+  cursor.execute(
+    "CREATE STABLE meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS (location BINARY(64), groupId INT)"
+  );
+}
+
+//ANCHOR: insertData
+function insertData() {
+  // init
+  cursor.stmtInit();
+  // prepare
+  cursor.stmtPrepare(
+    "INSERT INTO ? USING meters TAGS(?, ?) VALUES(?, ?, ?, ?)"
+  );
+
+  // bind table name and tags
+  let tagBind = new taos.TaosMultiBindArr(2);
+  tagBind.multiBindBinary(["California.SanFrancisco"]);
+  tagBind.multiBindInt([2]);
+  cursor.stmtSetTbnameTags("d1001", tagBind.getMultiBindArr());
+
+  // bind values
+  let valueBind = new taos.TaosMultiBindArr(4);
+  valueBind.multiBindTimestamp([1648432611249, 1648432611749]);
+  valueBind.multiBindFloat([10.3, 12.6]);
+  valueBind.multiBindInt([219, 218]);
+  valueBind.multiBindFloat([0.31, 0.33]);
+  cursor.stmtBindParamBatch(valueBind.getMultiBindArr());
+  cursor.stmtAddBatch();
+
+  // execute
+  cursor.stmtExecute();
+  cursor.stmtClose();
+}
+//ANCHOR_END: insertData
+
+try {
+  prepareSTable();
+  insertData();
+} finally {
+  cursor.close();
+  conn.close();
+}

docs/examples/node/nativeexample/opentsdb_json_example.js

+const taos = require("@tdengine/client");
+
+const conn = taos.connect({
+  host: "localhost",
+});
+
+const cursor = conn.cursor();
+
+function createDatabase() {
+  cursor.execute("CREATE DATABASE test");
+  cursor.execute("USE test");
+}
+
+function insertData() {
+  const lines = [
+    {
+      metric: "meters.current",
+      timestamp: 1648432611249,
+      value: 10.3,
+      tags: { location: "California.SanFrancisco", groupid: 2 },
+    },
+    {
+      metric: "meters.voltage",
+      timestamp: 1648432611249,
+      value: 219,
+      tags: { location: "California.LosAngeles", groupid: 1 },
+    },
+    {
+      metric: "meters.current",
+      timestamp: 1648432611250,
+      value: 12.6,
+      tags: { location: "California.SanFrancisco", groupid: 2 },
+    },
+    {
+      metric: "meters.voltage",
+      timestamp: 1648432611250,
+      value: 221,
+      tags: { location: "California.LosAngeles", groupid: 1 },
+    },
+  ];
+
+  cursor.schemalessInsert(
+    [JSON.stringify(lines)],
+    taos.SCHEMALESS_PROTOCOL.TSDB_SML_JSON_PROTOCOL,
+    taos.SCHEMALESS_PRECISION.TSDB_SML_TIMESTAMP_NOT_CONFIGURED
+  );
+}
+
+try {
+  createDatabase();
+  insertData();
+} finally {
+  cursor.close(); 
+  conn.close();
+}

docs/examples/node/nativeexample/opentsdb_telnet_example.js

+const taos = require("@tdengine/client");
+
+const conn = taos.connect({
+  host: "localhost",
+});
+
+const cursor = conn.cursor();
+
+function createDatabase() {
+  cursor.execute("CREATE DATABASE test");
+  cursor.execute("USE test");
+}
+
+function insertData() {
+  const lines = [
+    "meters.current 1648432611249 10.3 location=California.SanFrancisco groupid=2",
+    "meters.current 1648432611250 12.6 location=California.SanFrancisco groupid=2",
+    "meters.current 1648432611249 10.8 location=California.LosAngeles groupid=3",
+    "meters.current 1648432611250 11.3 location=California.LosAngeles groupid=3",
+    "meters.voltage 1648432611249 219 location=California.SanFrancisco groupid=2",
+    "meters.voltage 1648432611250 218 location=California.SanFrancisco groupid=2",
+    "meters.voltage 1648432611249 221 location=California.LosAngeles groupid=3",
+    "meters.voltage 1648432611250 217 location=California.LosAngeles groupid=3",
+  ];
+  cursor.schemalessInsert(
+    lines,
+    taos.SCHEMALESS_PROTOCOL.TSDB_SML_TELNET_PROTOCOL,
+    taos.SCHEMALESS_PRECISION.TSDB_SML_TIMESTAMP_NOT_CONFIGURED
+  );
+}
+
+try {
+  createDatabase();
+  insertData();
+} finally {
+  cursor.close();
+  conn.close();
+}

docs/examples/node/nativeexample/param_bind_example.js

+const taos = require("@tdengine/client");
+
+const conn = taos.connect({
+  host: "localhost",
+});
+
+const cursor = conn.cursor();
+
+function prepareSTable() {
+  cursor.execute("CREATE DATABASE power");
+  cursor.execute("USE power");
+  cursor.execute(
+    "CREATE STABLE meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS (location BINARY(64), groupId INT)"
+  );
+}
+
+function insertData() {
+  // init
+  cursor.stmtInit();
+  // prepare
+  cursor.stmtPrepare(
+    "INSERT INTO ? USING meters TAGS(?, ?) VALUES(?, ?, ?, ?)"
+  );
+
+  // bind table name and tags
+  let tagBind = new taos.TaosMultiBindArr(2);
+  tagBind.multiBindBinary(["California.SanFrancisco"]);
+  tagBind.multiBindInt([2]);
+  cursor.stmtSetTbnameTags("d1001", tagBind.getMultiBindArr());
+
+  // bind values
+  let rows = [[1648432611249, 1648432611749], [10.3, 12.6], [219, 218], [0.31, 0.33]];
+
+  let valueBind = new taos.TaosMultiBindArr(4);
+  valueBind.multiBindTimestamp(rows[0]);
+  valueBind.multiBindFloat(rows[1]);
+  valueBind.multiBindInt(rows[2]);
+  valueBind.multiBindFloat(rows[3]);
+  cursor.stmtBindParamBatch(valueBind.getMultiBindArr());
+  cursor.stmtAddBatch();
+
+
+  // execute
+  cursor.stmtExecute();
+  cursor.stmtClose();
+}
+
+try {
+  prepareSTable();
+  insertData();
+} finally {
+  cursor.close();
+  conn.close();
+}

docs/examples/node/nativeexample/query_example.js

+const taos = require("@tdengine/client");
+
+const conn = taos.connect({ host: "localhost", database: "power" });
+const cursor = conn.cursor();
+const query = cursor.query("SELECT ts, current FROM meters LIMIT 2");
+query.execute().then(function (result) {
+  result.pretty();
+});
+
+// output:
+// Successfully connected to TDengine
+//            ts             |         current          |
+// =======================================================
+// 2018-10-03 14:38:05.000   | 10.3                     |
+// 2018-10-03 14:38:15.000   | 12.6                     |

docs/examples/node/nativeexample/subscribe_demo.js

+const taos = require("@tdengine/client");
+
+const conn = taos.connect({ host: "localhost", database: "power" });
+var cursor = conn.cursor();
+
+function runConsumer() {
+
+    // create topic 
+    cursor.execute("create topic topic_name_example as select * from meters");
+
+    let consumer = taos.consumer({
+        'group.id': 'tg2',
+        'td.connect.user': 'root',
+        'td.connect.pass': 'taosdata',
+        'msg.with.table.name': 'true',
+        'enable.auto.commit': 'true'
+    });
+    
+    // subscribe the topic just created.
+    consumer.subscribe("topic_name_example");
+
+    // get subscribe topic list
+    let topicList = consumer.subscription();
+    console.log(topicList);
+
+    for (let i = 0; i < 5; i++) {
+        let msg = consumer.consume(100);
+        console.log(msg.topicPartition);
+        console.log(msg.block);
+        console.log(msg.fields)
+        consumer.commit(msg);
+        console.log(`=======consumer ${i} done`)
+    }
+
+    consumer.unsubscribe();
+    consumer.close();
+
+    // drop topic
+    cursor.execute("drop topic topic_name_example");
+}
+
+
+try {
+    runConsumer();
+} finally {
+
+    setTimeout(() => {
+        cursor.close();
+        conn.close();
+    }, 2000);
+}

docs/examples/node/package.json

@@ -4,6 +4,7 @@
   "main": "index.js",
   "license": "MIT",
   "dependencies": {
-    "td2.0-rest-connector": "^1.0.5"
+    "@tdengine/client": "^3.0.1",
+    "@tdengine/rest": "^3.0.0"
   }
 }

docs/examples/node/restexample/connect.js

+const { options, connect } = require("@tdengine/rest");
+
+async function test() {
+  options.path = "/rest/sql";
+  options.host = "localhost";
+  let conn = connect(options);
+  let cursor = conn.cursor();
+  try {
+    let res = await cursor.query("SELECT server_version()");
+    res.toString();
+  } catch (err) {
+    console.log(err);
+  }
+}
+test();
+
+// output:
+// server_version() |
+// ===================
+// 3.0.0.0          |

docs/examples/php/connect.php

+<?php
+
+use TDengine\Connection;
+use TDengine\Exception\TDengineException;
+
+try {
+    // instantiate
+    $host = 'localhost';
+    $port = 6030;
+    $username = 'root';
+    $password = 'taosdata';
+    $dbname = null;
+    $connection = new Connection($host, $port, $username, $password, $dbname);
+
+    // connect
+    $connection->connect();
+} catch (TDengineException $e) {
+    // throw exception
+    throw $e;
+}

docs/examples/php/insert.php

+<?php
+
+use TDengine\Connection;
+use TDengine\Exception\TDengineException;
+
+try {
+    // instantiate
+    $host = 'localhost';
+    $port = 6030;
+    $username = 'root';
+    $password = 'taosdata';
+    $dbname = 'power';
+    $connection = new Connection($host, $port, $username, $password, $dbname);
+
+    // connect
+    $connection->connect();
+
+    // insert
+    $connection->query('CREATE DATABASE if not exists power');
+    $connection->query('CREATE STABLE if not exists meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS (location BINARY(64), groupId INT)');
+    $resource = $connection->query(<<<'SQL'
+    INSERT INTO power.d1001 USING power.meters TAGS(California.SanFrancisco, 2) VALUES ('2018-10-03 14:38:05.000', 10.30000, 219, 0.31000) ('2018-10-03 14:38:15.000', 12.60000, 218, 0.33000) ('2018-10-03 14:38:16.800', 12.30000, 221, 0.31000)
+    power.d1002 USING power.meters TAGS(California.SanFrancisco, 3) VALUES ('2018-10-03 14:38:16.650', 10.30000, 218, 0.25000)
+    power.d1003 USING power.meters TAGS(California.LosAngeles, 2) VALUES ('2018-10-03 14:38:05.500', 11.80000, 221, 0.28000) ('2018-10-03 14:38:16.600', 13.40000, 223, 0.29000)
+    power.d1004 USING power.meters TAGS(California.LosAngeles, 3) VALUES ('2018-10-03 14:38:05.000', 10.80000, 223, 0.29000) ('2018-10-03 14:38:06.500', 11.50000, 221, 0.35000)
+    SQL);
+
+    // get affected rows
+    var_dump($resource->affectedRows());
+} catch (TDengineException $e) {
+    // throw exception
+    throw $e;
+}

docs/examples/php/insert_stmt.php

+<?php
+
+use TDengine\Connection;
+use TDengine\Exception\TDengineException;
+
+try {
+    // instantiate
+    $host = 'localhost';
+    $port = 6030;
+    $username = 'root';
+    $password = 'taosdata';
+    $dbname = 'power';
+    $connection = new Connection($host, $port, $username, $password, $dbname);
+
+    // connect
+    $connection->connect();
+
+    // insert
+    $connection->query('CREATE DATABASE if not exists power');
+    $connection->query('CREATE STABLE if not exists meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS (location BINARY(64), groupId INT)');
+    $stmt = $connection->prepare('INSERT INTO ? USING meters TAGS(?, ?) VALUES(?, ?, ?, ?)');
+
+    // set table name and tags
+    $stmt->setTableNameTags('d1001', [
+        // same format as parameter binding
+        [TDengine\TSDB_DATA_TYPE_BINARY, 'California.SanFrancisco'],
+        [TDengine\TSDB_DATA_TYPE_INT, 2],
+    ]);
+
+    $stmt->bindParams([
+        [TDengine\TSDB_DATA_TYPE_TIMESTAMP, 1648432611249],
+        [TDengine\TSDB_DATA_TYPE_FLOAT, 10.3],
+        [TDengine\TSDB_DATA_TYPE_INT, 219],
+        [TDengine\TSDB_DATA_TYPE_FLOAT, 0.31],
+    ]);
+    $stmt->bindParams([
+        [TDengine\TSDB_DATA_TYPE_TIMESTAMP, 1648432611749],
+        [TDengine\TSDB_DATA_TYPE_FLOAT, 12.6],
+        [TDengine\TSDB_DATA_TYPE_INT, 218],
+        [TDengine\TSDB_DATA_TYPE_FLOAT, 0.33],
+    ]);
+    $resource = $stmt->execute();
+
+    // get affected rows
+    var_dump($resource->affectedRows());
+} catch (TDengineException $e) {
+    // throw exception
+    throw $e;
+}

docs/examples/php/query.php

+<?php
+
+use TDengine\Connection;
+use TDengine\Exception\TDengineException;
+
+try {
+    // instantiate
+    $host = 'localhost';
+    $port = 6030;
+    $username = 'root';
+    $password = 'taosdata';
+    $dbname = 'power';
+    $connection = new Connection($host, $port, $username, $password, $dbname);
+
+    // connect
+    $connection->connect();
+
+    $resource = $connection->query('SELECT ts, current FROM meters LIMIT 2');
+    var_dump($resource->fetch());
+} catch (TDengineException $e) {
+    // throw exception
+    throw $e;
+}

docs/examples/python/.gitignore

+.idea
\ No newline at end of file

docs/examples/python/conn_native_pandas.py

+import pandas
+from sqlalchemy import create_engine
+
+engine = create_engine("taos://root:taosdata@localhost:6030/power")
+df = pandas.read_sql("SELECT * FROM meters", engine)
+
+# print index
+print(df.index)
+# print data type  of element in ts column
+print(type(df.ts[0]))
+print(df.head(3))
+
+# output:
+# RangeIndex(start=0, stop=8, step=1)
+# <class 'pandas._libs.tslibs.timestamps.Timestamp'>
+#                        ts  current  ...               location  groupid
+# 0 2018-10-03 14:38:05.500     11.8  ...  california.losangeles        2
+# 1 2018-10-03 14:38:16.600     13.4  ...  california.losangeles        2
+# 2 2018-10-03 14:38:05.000     10.8  ...  california.losangeles        3

docs/examples/python/conn_rest_pandas.py

+import pandas
+from sqlalchemy import create_engine
+
+engine = create_engine("taosrest://root:taosdata@localhost:6041")
+df: pandas.DataFrame = pandas.read_sql("SELECT * FROM power.meters", engine)
+
+# print index
+print(df.index)
+# print data type  of element in ts column
+print(type(df.ts[0]))
+print(df.head(3))
+
+# output:
+# RangeIndex(start=0, stop=8, step=1)
+# <class 'pandas._libs.tslibs.timestamps.Timestamp'>
+#                                 ts  current  ...               location  groupid
+# 0 2018-10-03 06:38:05.500000+00:00     11.8  ...  california.losangeles        2
+# 1 2018-10-03 06:38:16.600000+00:00     13.4  ...  california.losangeles        2
+# 2        2018-10-03 06:38:05+00:00     10.8  ...  california.losangeles        3