[TD-4669] <docs>: upload English documents & pictures for version 2.0.

documentation20/en/05.insert/docs.md

+# Efficient Data Writing
+
+TDengine supports multiple interfaces to write data, including SQL, Prometheus, Telegraf, EMQ MQTT Broker, HiveMQ Broker, CSV file, etc. Kafka, OPC and other interfaces will be provided in the future. Data can be inserted in a single piece or in batches, data from one or multiple data collection points can be inserted at the same time. TDengine supports multi-thread insertion, nonsequential data insertion, and also historical data insertion.
+
+## <a class="anchor" id="sql"></a> SQL Writing
+
+Applications insert data by executing SQL insert statements through C/C + +, JDBC, GO, or Python Connector, and users can manually enter SQL insert statements to insert data through TAOS Shell. For example, the following insert writes a record to table d1001:
+
+```mysql
+```
+
+INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31);
+
+```
+```
+
+TDengine supports writing multiple records at a time. For example, the following command writes two records to table d1001:
+
+```mysql
+```
+
+INSERT INTO d1001 VALUES (1538548684000, 10.2, 220, 0.23) (1538548696650, 10.3, 218, 0.25);
+
+```
+```
+
+TDengine also supports writing data to multiple tables at a time. For example, the following command writes two records to d1001 and one record to d1002:
+
+```mysql
+```
+
+INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31) (1538548695000, 12.6, 218, 0.33) d1002 VALUES (1538548696800, 12.3, 221, 0.31);
+
+```
+```
+
+For the SQL INSERT Grammar, please refer to  [Taos SQL insert](https://www.taosdata.com/en/documentation/taos-sql#insert)。
+
+**Tips:**
+
+- To improve writing efficiency, batch writing is required. The more records written in a batch, the higher the insertion efficiency. However, a record cannot exceed 16K, and the total length of an SQL statement cannot exceed 64K (it can be configured by parameter maxSQLLength, and the maximum can be configured to 1M).
+- TDengine supports multi-thread parallel writing. To further improve writing speed, a client needs to open more than 20 threads to write parallelly. However, after the number of threads reaches a certain threshold, it cannot be increased or even become decreased, because too much frequent thread switching brings extra overhead.
+- For a same table, if the timestamp of a newly inserted record already exists, (no database was created using UPDATE 1) the new record will be discarded as default, that is, the timestamp must be unique in a table. If an application automatically generates records, it is very likely that the generated timestamps will be the same, so the number of records successfully inserted will be smaller than the number of records the application try to insert. If you use UPDATE 1 option when creating a database, inserting a new record with the same timestamp will overwrite the original record.
+- The timestamp of written data must be greater than the current time minus the time of configuration parameter keep. If keep is configured for 3650 days, data older than 3650 days cannot be written. The timestamp for writing data cannot be greater than the current time plus configuration parameter days. If days is configured to 2, data 2 days later than the current time cannot be written.
+
+## <a class="anchor" id="prometheus"></a> Direct Writing of Prometheus
+
+As a graduate project of Cloud Native Computing Foundation, [Prometheus](https://www.prometheus.io/) is widely used in the field of performance monitoring and K8S performance monitoring. TDengine provides a simple tool [Bailongma](https://github.com/taosdata/Bailongma), which only needs to be simply configured in Prometheus without any code, and can directly write the data collected by Prometheus into TDengine, then automatically create databases and related table entries in TDengine according to rules. Blog post [Use Docker Container to Quickly Build a Devops Monitoring Demo](https://www.taosdata.com/blog/2020/02/03/1189.html), which is an example of using bailongma to write Prometheus and Telegraf data into TDengine.
+
+### Compile blm_prometheus From Source
+
+Users need to download the source code of [Bailongma](https://github.com/taosdata/Bailongma) from github, then compile and generate an executable file using Golang language compiler. Before you start compiling, you need to complete following prepares:
+
+- A server running Linux OS
+- Golang version 1.10 and higher installed
+- An appropriated TDengine version. Because the client dynamic link library of TDengine is used, it is necessary to install the same version of TDengine as the server-side; for example, if the server version is TDengine 2.0. 0, ensure install the same version on the linux server where bailongma is located (can be on the same server as TDengine, or on a different server)
+
+Bailongma project has a folder, blm_prometheus, which holds the prometheus writing API. The compiling process is as follows:
+
+```bash
+```
+
+cd blm_prometheus
+
+go build
+
+```
+```
+
+If everything goes well, an executable of blm_prometheus will be generated in the corresponding directory.
+
+### Install Prometheus
+
+Download and install as the instruction of Prometheus official website. [Download Address](https://prometheus.io/download/)
+
+### Configure Prometheus
+
+Read the Prometheus [configuration document](https://prometheus.io/docs/prometheus/latest/configuration/configuration/) and add following configurations in the section of Prometheus configuration file
+
+- url: The URL provided by bailongma API service, refer to the blm_prometheus startup example section below
+
+After Prometheus launched, you can check whether data is written successfully through query taos client.
+
+### Launch blm_prometheus
+
+blm_prometheus has following options that you can configure when you launch blm_prometheus.
+
+```sh
+--tdengine-name
+
+If TDengine is installed on a server with a domain name, you can also access the TDengine by configuring the domain name of it. In K8S environment, it can be configured as the service name that TDengine runs
+
+--batch-size
+
+blm_prometheus assembles the received prometheus data into a TDengine writing request. This parameter controls the number of data pieces carried in a writing request sent to TDengine at a time.
+
+--dbname
+
+Set a name for the database created in TDengine, blm_prometheus will automatically create a database named dbname in TDengine, and the default value is prometheus.
+
+--dbuser
+
+Set the user name to access TDengine, the default value is'root '
+
+--dbpassword
+
+Set the password to access TDengine, the default value is'taosdata '
+
+--port
+
+The port number blm_prometheus used to serve prometheus.
+```
+
+
+
+### Example
+
+Launch an API service for blm_prometheus with the following command:
+
+```bash
+./blm_prometheus -port 8088
+```
+
+Assuming that the IP address of the server where blm_prometheus located is "10.1.2. 3", the URL shall be added to the configuration file of Prometheus as:
+
+remote_write:
+
+\- url: "http://10.1.2.3:8088/receive"
+
+
+
+### Query written data of prometheus
+
+The format of generated data by Prometheus is as follows:
+
+```json
+
+
+{
+  Timestamp: 1576466279341,
+  Value: 37.000000, 
+  apiserver_request_latencies_bucket {
+  component="apiserver", 
+   instance="192.168.99.116:8443", 
+   job="kubernetes-apiservers", 
+   le="125000", 
+   resource="persistentvolumes", s
+   cope="cluster",
+   verb="LIST", 
+   version=“v1" 
+  }
+}
+```
+
+Where apiserver_request_latencies_bucket is the name of the time-series data collected by prometheus, and the tag of the time-series data is in the following {}. blm_prometheus automatically creates a STable in TDengine with the name of the time series data, and converts the tag in {} into the tag value of TDengine, with Timestamp as the timestamp and value as the value of the time-series data. Therefore, in the client of TDEngine, you can check whether this data was successfully written through the following instruction.
+
+```mysql
+use prometheus;
+
+select * from apiserver_request_latencies_bucket;
+```
+
+
+
+## <a class="anchor" id="telegraf"></a> Direct Writing of Telegraf
+
+[Telegraf](https://www.influxdata.com/time-series-platform/telegraf/) is a popular open source tool for IT operation data collection. TDengine provides a simple tool [Bailongma](https://github.com/taosdata/Bailongma), which only needs to be simply configured in Telegraf without any code, and can directly write the data collected by Telegraf into TDengine, then automatically create databases and related table entries in TDengine according to rules. Blog post [Use Docker Container to Quickly Build a Devops Monitoring Demo](https://www.taosdata.com/blog/2020/02/03/1189.html), which is an example of using bailongma to write Prometheus and Telegraf data into TDengine.
+
+### Compile blm_telegraf From Source Code
+
+Users need to download the source code of [Bailongma](https://github.com/taosdata/Bailongma) from github, then compile and generate an executable file using Golang language compiler. Before you start compiling, you need to complete following prepares:
+
+- A server running Linux OS
+- Golang version 1.10 and higher installed
+- An appropriated TDengine version. Because the client dynamic link library of TDengine is used, it is necessary to install the same version of TDengine as the server-side; for example, if the server version is TDengine 2.0. 0, ensure install the same version on the linux server where bailongma is located (can be on the same server as TDengine, or on a different server)
+
+Bailongma project has a folder, blm_telegraf, which holds the Telegraf writing API. The compiling process is as follows:
+
+```bash
+cd blm_telegraf
+
+go build
+```
+
+If everything goes well, an executable of blm_telegraf will be generated in the corresponding directory.
+
+### Install Telegraf
+
+At the moment, TDengine supports Telegraf version 1.7. 4 and above. Users can download the installation package on Telegraf's website according to your current operating system. The download address is as follows: https://portal.influxdata.com/downloads
+
+### Configure Telegraf
+
+Modify the TDengine-related configurations in the Telegraf configuration file /etc/telegraf/telegraf.conf.
+
+In the output plugins section, add the [[outputs.http]] configuration:
+
+- url: The URL provided by bailongma API service, please refer to the example section below
+- data_format: "json"
+- json_timestamp_units: "1ms"
+
+In agent section:
+
+- hostname: The machine name that distinguishes different collection devices, and it is necessary to ensure its uniqueness
+- metric_batch_size: 100, which is the max number of records per batch wriiten by Telegraf allowed. Increasing the number can reduce the request sending frequency of Telegraf.
+
+For information on how to use Telegraf to collect data and more about using Telegraf, please refer to the official [document](https://docs.influxdata.com/telegraf/v1.11/) of Telegraf.
+
+### Launch blm_telegraf
+
+blm_telegraf has following options, which can be set to tune configurations of blm_telegraf when launching.
+
+```sh
+--host
+
+The ip address of TDengine server, default is null
+
+--batch-size
+
+blm_prometheus assembles the received telegraf data into a TDengine writing request. This parameter controls the number of data pieces carried in a writing request sent to TDengine at a time.
+
+--dbname
+
+Set a name for the database created in TDengine, blm_telegraf will automatically create a database named dbname in TDengine, and the default value is prometheus.
+
+--dbuser
+
+Set the user name to access TDengine, the default value is 'root '
+
+--dbpassword
+
+Set the password to access TDengine, the default value is'taosdata '
+
+--port
+
+The port number blm_telegraf used to serve Telegraf.
+```
+
+
+
+### Example
+
+Launch an API service for blm_telegraf with the following command
+
+```bash
+./blm_telegraf -host 127.0.0.1 -port 8089
+```
+
+Assuming that the IP address of the server where blm_telegraf located is "10.1.2. 3", the URL shall be added to the configuration file of telegraf as:
+
+```yaml
+url = "http://10.1.2.3:8089/telegraf"
+```
+
+### Query written data of telegraf
+
+The format of generated data by telegraf is as follows:
+
+```json
+{
+  "fields": {
+    "usage_guest": 0, 
+    "usage_guest_nice": 0,
+    "usage_idle": 89.7897897897898, 
+    "usage_iowait": 0,
+    "usage_irq": 0,
+    "usage_nice": 0,
+    "usage_softirq": 0,
+    "usage_steal": 0,
+    "usage_system": 5.405405405405405, 
+    "usage_user": 4.804804804804805
+  },
+  
+  "name": "cpu", 
+  "tags": {
+    "cpu": "cpu2",
+    "host": "bogon" 
+  },
+  "timestamp": 1576464360 
+}
+```
+
+Where the name field is the name of the time-series data collected by telegraf, and the tag field is the tag of the time-series data. blm_telegraf automatically creates a STable in TDengine with the name of the time series data, and converts the tag field into the tag value of TDengine, with Timestamp as the timestamp and fields values as the value of the time-series data. Therefore, in the client of TDEngine, you can check whether this data was successfully written through the following instruction.
+
+```mysql
+use telegraf;
+
+select * from cpu;
+```
+
+MQTT is a popular data transmission protocol in the IoT. TDengine can easily access the data received by MQTT Broker and write it to TDengine.
+
+## <a class="anchor" id="emq"></a> Direct Writing of EMQ Broker
+
+[EMQ](https://github.com/emqx/emqx) is an open source MQTT Broker software, with no need of coding, only to use "rules" in EMQ Dashboard for simple configuration, and MQTT data can be directly written into TDengine. EMQ X supports storing data to the TDengine by sending it to a Web service, and also provides a native TDengine driver on Enterprise Edition for direct data store. Please refer to [EMQ official documents](https://docs.emqx.io/broker/latest/cn/rule/rule-example.html#%E4%BF%9D%E5%AD%98%E6%95%B0%E6%8D%AE%E5%88%B0-tdengine) for more details.
+
+
+
+## <a class="anchor" id="hivemq"></a> Direct Writing of HiveMQ Broker
+
+[HiveMQ](https://www.hivemq.com/) is an MQTT agent that provides Free Personal and Enterprise Edition versions. It is mainly used for enterprises, emerging machine-to-machine(M2M) communication and internal transmission to meet scalability, easy management and security features. HiveMQ provides an open source plug-in development kit. You can store data to TDengine via HiveMQ extension-TDengine. Refer to the [HiveMQ extension-TDengine documentation](https://github.com/huskar-t/hivemq-tdengine-extension/blob/b62a26ecc164a310104df57691691b237e091c89/README.md) for more details.
\ No newline at end of file

documentation20/en/06.queries/docs.md

+# Efficient Data Querying
+
+## <a class="anchor" id="queries"></a> Main Query Features
+
+TDengine uses SQL as the query language. Applications can send SQL statements through C/C + +, Java, Go, Python connectors, and users can manually execute SQL Ad-Hoc Query through the Command Line Interface (CLI) tool TAOS Shell provided by TDengine. TDengine supports the following query functions:
+
+- Single-column and multi-column data query
+- Multiple filters for tags and numeric values: >, <, =, < >, like, etc
+- Group by, Order by, Limit/Offset of aggregation results
+- Four operations for numeric columns and aggregation results
+- Time stamp aligned join query (implicit join) operations
+- Multiple aggregation/calculation functions: count, max, min, avg, sum, twa, stddev, leastsquares, top, bottom, first, last, percentile, apercentile, last_row, spread, diff, etc
+
+For example, in TAOS shell, the records with vlotage > 215 are queried from table d1001, sorted in descending order by timestamps, and only two records are outputted.
+
+```mysql
+taos> select * from d1001 where voltage > 215 order by ts desc limit 2;
+           ts            |       current        |   voltage   |        phase         |
+======================================================================================
+ 2018-10-03 14:38:16.800 |             12.30000 |         221 |              0.31000 |
+ 2018-10-03 14:38:15.000 |             12.60000 |         218 |              0.33000 |
+Query OK, 2 row(s) in set (0.001100s)
+```
+
+In order to meet the needs of an IoT scenario, TDengine supports several special functions, such as twa (time weighted average), spread (difference between maximum and minimum), last_row (last record), etc. More functions related to IoT scenarios will be added. TDengine also supports continuous queries.
+
+For specific query syntax, please see the [Data Query section of TAOS SQL](https://www.taosdata.com/cn/documentation/taos-sql#select).
+
+## <a class="anchor" id="aggregation"></a> Multi-table Aggregation Query
+
+In an IoT scenario, there are often multiple data collection points in a same type. TDengine uses the concept of STable to describe a certain type of data collection point, and an ordinary table to describe a specific data collection point. At the same time, TDengine uses tags to describe the statical attributes of data collection points. A given data collection point has a specific tag value. By specifying the filters of tags, TDengine provides an efficient method to aggregate and query the sub-tables of STables (data collection points of a certain type). Aggregation functions and most operations on ordinary tables are applicable to STables, and the syntax is exactly the same.
+
+**Example 1**: In TAOS Shell, look up the average voltages collected by all smart meters in Beijing and group them by location
+
+```mysql
+taos> SELECT AVG(voltage) FROM meters GROUP BY location;
+       avg(voltage)        |            location            |
+=============================================================
+             222.000000000 | Beijing.Haidian                |
+             219.200000000 | Beijing.Chaoyang               |
+Query OK, 2 row(s) in set (0.002136s)
+```
+
+**Example 2**: In TAOS Shell, look up the number of records with groupId 2 in the past 24 hours, check the maximum current of all smart meters
+
+```mysql
+taos> SELECT count(*), max(current) FROM meters where groupId = 2 and ts > now - 24h;
+     cunt(*)  |    max(current)  |
+==================================
+            5 |             13.4 |
+Query OK, 1 row(s) in set (0.002136s)
+```
+
+TDengine only allows aggregation queries between tables belonging to a same STable, means aggregation queries between different STables are not supported. In the Data Query section of TAOS SQL, query class operations will all be indicated that whether STables are supported.
+
+## <a class="anchor" id="sampling"></a> Down Sampling Query, Interpolation
+
+In a scenario of IoT, it is often necessary to aggregate the collected data by intervals through down sampling. TDengine provides a simple keyword interval, which makes query operations according to time windows extremely simple. For example, the current values collected by smart meter d1001 are summed every 10 seconds.
+
+```mysql
+taos> SELECT sum(current) FROM d1001 INTERVAL(10s);
+           ts            |       sum(current)        |
+======================================================
+ 2018-10-03 14:38:00.000 |              10.300000191 |
+ 2018-10-03 14:38:10.000 |              24.900000572 |
+Query OK, 2 row(s) in set (0.000883s)
+```
+
+The down sampling operation is also applicable to STables, such as summing the current values collected by all smart meters in Beijing every second.
+
+```mysql
+taos> SELECT SUM(current) FROM meters where location like "Beijing%" INTERVAL(1s);
+           ts            |       sum(current)        |
+======================================================
+ 2018-10-03 14:38:04.000 |              10.199999809 |
+ 2018-10-03 14:38:05.000 |              32.900000572 |
+ 2018-10-03 14:38:06.000 |              11.500000000 |
+ 2018-10-03 14:38:15.000 |              12.600000381 |
+ 2018-10-03 14:38:16.000 |              36.000000000 |
+Query OK, 5 row(s) in set (0.001538s)
+```
+
+The down sampling operation also supports time offset, such as summing the current values collected by all smart meters every second, but requires each time window to start from 500 milliseconds.
+
+```mysql
+taos> SELECT SUM(current) FROM meters INTERVAL(1s, 500a);
+           ts            |       sum(current)        |
+======================================================
+ 2018-10-03 14:38:04.500 |              11.189999809 |
+ 2018-10-03 14:38:05.500 |              31.900000572 |
+ 2018-10-03 14:38:06.500 |              11.600000000 |
+ 2018-10-03 14:38:15.500 |              12.300000381 |
+ 2018-10-03 14:38:16.500 |              35.000000000 |
+Query OK, 5 row(s) in set (0.001521s)
+```
+
+In a scenario of IoT, it is difficult to synchronize the time stamp of collected data at each point, but many analysis algorithms (such as FFT) need to align the collected data strictly at equal intervals of time. In many systems, it’s required to write their own programs to process, but the down sampling operation of TDengine can be easily solved. If there is no collected data in an interval, TDengine also provides interpolation calculation function.
+
+For details of syntax rules, please refer to the [Time-dimension Aggregation section of TAOS SQL](https://www.taosdata.com/en/documentation/taos-sql#aggregation).
\ No newline at end of file

documentation20/en/09.connections/docs.md

+# Connections with Other Tools
+
+## <a class="anchor" id="grafana"></a> Grafana
+
+TDengine can quickly integrate with [Grafana](https://www.grafana.com/), an open source data visualization system, to build a data monitoring and alarming system. The whole process does not require any code to write. The contents of the data table in TDengine can be visually showed on DashBoard.
+
+### Install Grafana
+
+TDengine currently supports Grafana 5.2.4 and above. You can download and install the package from Grafana website according to the current operating system. The download address is as follows:
+
+https://grafana.com/grafana/download.
+
+### Configure Grafana
+
+TDengine Grafana plugin is in the /usr/local/taos/connector/grafanaplugin directory. 
+
+Taking Centos 7.2 as an example, just copy grafanaplugin directory to /var/lib/grafana/plugins directory and restart Grafana.
+
+```bash
+sudo cp -rf /usr/local/taos/connector/grafanaplugin /var/lib/grafana/plugins/tdengine
+```
+
+### Use Grafana
+
+#### Configure data source
+
+You can log in the Grafana server (username/password:admin/admin) through localhost:3000, and add data sources through `Configuration -> Data Sources` on the left panel, as shown in the following figure:
+
+![img](page://images/connections/add_datasource1.jpg)
+
+Click `Add data source` to enter the Add Data Source page, and enter TDengine in the query box to select Add, as shown in the following figure:
+
+![img](page://images/connections/add_datasource2.jpg)
+
+Enter the data source configuration page and modify the corresponding configuration according to the default prompt:
+
+![img](page://images/connections/add_datasource3.jpg)
+
+- Host: IP address of any server in TDengine cluster and port number of TDengine RESTful interface (6041), default  [http://localhost:6041](http://localhost:6041/)
+- User: TDengine username.
+- Password: TDengine user password.
+
+Click `Save & Test` to test. Success will be prompted as follows:
+
+![img](page://images/connections/add_datasource4.jpg)
+
+#### Create Dashboard
+
+Go back to the home  to create Dashboard, and click `Add Query` to enter the panel query page:
+
+![img](page://images/connections/create_dashboard1.jpg)
+
+As shown in the figure above, select the TDengine data source in Query, and enter the corresponding sql in the query box below to query. Details are as follows:
+
+- INPUT SQL: Enter the statement to query (the result set of the SQL statement should be two columns and multiple rows), for example: `select avg(mem_system) from log.dn where ts >= $from and ts < $to interval($interval)` , where `from`, `to` and `interval` are built-in variables of the TDengine plug-in, representing the query range and time interval obtained from the Grafana plug-in panel. In addition to built-in variables, it is also supported to use custom template variables.
+- ALIAS BY: You can set alias for the current queries.
+- GENERATE SQL: Clicking this button will automatically replace the corresponding variable and generate the final statement to execute.
+
+According to the default prompt, query the average system memory usage at the specified interval of the server where the current TDengine deployed in as follows:
+
+![img](page://images/connections/create_dashboard2.jpg)
+
+> Please refer to Grafana [documents](https://grafana.com/docs/) for how to use Grafana to create the corresponding monitoring interface and for more about Grafana usage.
+
+#### Import Dashboard
+
+A `tdengine-grafana.json` importable dashboard is provided under the Grafana plug-in directory/usr/local/taos/connector/grafana/tdengine/dashboard/.
+
+Click the `Import` button on the left panel and upload the  `tdengine-grafana.json` file:
+
+![img](page://images/connections/import_dashboard1.jpg)
+
+You can see as follows after Dashboard imported.
+
+![img](page://images/connections/import_dashboard2.jpg)
+
+## <a class="anchor" id="matlab"></a> Matlab
+
+MatLab can access data to the local workspace by connecting directly to the TDengine via the JDBC Driver provided in the installation package.
+
+### JDBC Interface Adaptation of MatLab
+
+Several steps are required to adapt Matlab to TDengine. Taking adapting Matlab2017a on Windows10 as an example:
+
+- Copy the file JDBCDriver-1.0.0-dist.ja*r* in TDengine package to the directory ${matlab_root}\MATLAB\R2017a\java\jar\toolbox
+- Copy the file taos.lib in TDengine package to ${matlab root dir}\MATLAB\R2017a\lib\win64
+- Add the .jar package just copied to the Matlab classpath. Append the line below as the end of the file of ${matlab root dir}\MATLAB\R2017a\toolbox\local\classpath.txt
+- ```
+  $matlabroot/java/jar/toolbox/JDBCDriver-1.0.0-dist.jar
+  ```
+
+- Create a file called javalibrarypath.txt in directory ${user_home}\AppData\Roaming\MathWorks\MATLAB\R2017a_, and add the _taos.dll path in the file. For example, if the file taos.dll is in the directory of C:\Windows\System32，then add the following line in file javalibrarypath.txt:
+- ```
+  C:\Windows\System32
+  ```
+
+- ### Connect to TDengine in MatLab to get data
+
+After the above configured successfully, open MatLab.
+
+- Create a connection:
+
+```matlab
+conn = database(‘db’, ‘root’, ‘taosdata’, ‘com.taosdata.jdbc.TSDBDriver’, ‘jdbc:TSDB://127.0.0.1:0/’)
+```
+
+* Make a query:
+
+```matlab
+sql0 = [‘select * from tb’]
+data = select(conn, sql0);
+```
+
+* Insert a record:
+
+```matlab
+sql1 = [‘insert into tb values (now, 1)’]
+exec(conn, sql1)
+```
+
+For more detailed examples, please refer to the examples\Matlab\TDEngineDemo.m file in the package.
+
+## <a class="anchor" id="r"></a> R 
+
+R language supports connection to the TDengine database through the JDBC interface. First, you need to install the JDBC package of R language. Launch the R language environment, and then execute the following command to install the JDBC support library for R language:
+
+```R
+install.packages('RJDBC', repos='http://cran.us.r-project.org')
+```
+
+After installed, load the RJDBC package by executing `library('RJDBC')` command.
+
+Then load the TDengine JDBC driver:
+
+```R
+drv<-JDBC("com.taosdata.jdbc.TSDBDriver","JDBCDriver-2.0.0-dist.jar", identifier.quote="\"")
+```
+
+If succeed, no error message will display. Then use the following command to try a database connection:
+
+```R
+conn<-dbConnect(drv,"jdbc:TSDB://192.168.0.1:0/?user=root&password=taosdata","root","taosdata")
+```
+
+Please replace the IP address in the command above to the correct one. If no error message is shown, then the connection is established successfully, otherwise the connection command needs to be adjusted according to the error prompt. TDengine supports below functions in *RJDBC* package:
+
+- `dbWriteTable(conn, "test", iris, overwrite=FALSE, append=TRUE)`: Write the data in a data frame iris to the table test in the TDengine server. Parameter overwrite must be false. append must be TRUE and the schema of the data frame iris should be the same as the table test.
+- `dbGetQuery(conn, "select count(*) from test")`: run a query command
+- `dbSendUpdate (conn, "use db")`: Execute any non-query sql statement. For example, `dbSendUpdate (conn, "use db")`, write data `dbSendUpdate (conn, "insert into t1 values (now, 99)")`, and the like.
+- `dbReadTable(conn, "test")`: read all the data in table test
+- `dbDisconnect(conn)`: close a connection
+- `dbRemoveTable(conn, "test")`: remove table test
+
+The functions below are not supported currently:
+
+- `dbExistsTable(conn, "test")`: if table test exists
+- `dbListTables(conn)`: list all tables in the connection
\ No newline at end of file

documentation20/en/13.faq/docs.md

+# FAQ
+
+Tutorials & FAQ
+
+## 0.How to report an issue?
+
+If the contents in FAQ cannot help you and you need the technical support and assistance of TDengine team, please package the contents in the following two directories:
+
+1./var/log/taos (if default path has not been modified)
+
+2./etc/taos
+
+Provide the necessary description of the problem, including the version information of TDengine used, the platform environment information, the execution operation of the problem, the characterization of the problem and the approximate time, and submit the Issue on [GitHub](https://github.com/taosdata/TDengine).
+
+To ensure that there is enough debug information, if the problem can be repeated, please modify the/etc/taos/taos.cfg file, add a line of "debugFlag 135" at the end (without quotation marks themselves), then restart taosd, repeat the problem, and then submit. You can also temporarily set the log level of taosd through the following SQL statement.
+
+```
+    alter dnode <dnode_id> debugFlag 135;
+```
+
+However, when the system is running normally, please set debugFlag to 131, otherwise a large amount of log information will be generated and the system efficiency will be reduced.
+
+## 1.What should I pay attention to when upgrading TDengine from older versions to 2.0 and above? ☆☆☆
+
+Version 2.0 is a complete refactoring of the previous version, and the configuration and data files are incompatible. Be sure to do the following before upgrading:
+
+1. Delete the configuration file, execute sudo rm `-rf /etc/taos/taos.cfg`
+2. Delete the log file, execute `sudo rm -rf /var/log/taos/`
+3. By ensuring that the data is no longer needed, delete the data file and execute `sudo rm -rf /var/lib/taos/`
+4. Install the latest stable version of TDengine
+5. If you need to migrate data or the data file is corrupted, please contact the official technical support team of TAOS Data to assist
+
+## 2. When encoutered with the error " Unable to establish connection " in Windows, what can I do?
+
+See the [technical blog](https://www.taosdata.com/blog/2019/12/03/jdbcdriver%E6%89%BE%E4%B8%8D%E5%88%B0%E5%8A%A8%E6%80%81%E9%93%BE%E6%8E%A5%E5%BA%93/) for this issue.
+
+## 3. Why I get “more dnodes are needed” when create a table?
+
+See the [technical blog](https://www.taosdata.com/blog/2019/12/03/%E5%88%9B%E5%BB%BA%E6%95%B0%E6%8D%AE%E8%A1%A8%E6%97%B6%E6%8F%90%E7%A4%BAmore-dnodes-are-needed/) for this issue.
+
+## 4. How do I generate a core file when TDengine crashes?
+
+See the [technical blog](https://www.taosdata.com/blog/2019/12/06/tdengine-crash%E6%97%B6%E7%94%9F%E6%88%90core%E6%96%87%E4%BB%B6%E7%9A%84%E6%96%B9%E6%B3%95/) for this issue.
+
+## 5. What should I do if I encounter an error "Unable to establish connection"?
+
+When the client encountered a connection failure, please follow the following steps to check:
+
+1. Check your network environment
+
+2. - Cloud server: Check whether the security group of the cloud server opens access to TCP/UDP ports 6030-6042
+   - Local virtual machine: Check whether the network can be pinged, and try to avoid using localhost as hostname
+   - Corporate server: If you are in a NAT network environment, be sure to check whether the server can return messages to the client
+
+2. Make sure that the client and server version numbers are exactly the same, and the open source Community Edition and Enterprise Edition cannot be mixed.
+3. On the server, execute systemctl status taosd to check the running status of *taosd*. If not running, start *taosd*.
+4. Verify that the correct server FQDN (Fully Qualified Domain Name, which is available by executing the Linux command hostname-f on the server) is specified when the client connects. FQDN configuration reference: "[All about FQDN of TDengine](https://www.taosdata.com/blog/2020/09/11/1824.html)".
+5. Ping the server FQDN. If there is no response, please check your network, DNS settings, or the system hosts file of the computer where the client is located.
+6. Check the firewall settings (Ubuntu uses ufw status, CentOS uses firewall-cmd-list-port) to confirm that TCP/UDP ports 6030-6042 are open.
+7. For JDBC (ODBC, Python, Go and other interfaces are similar) connections on Linux, make sure that libtaos.so is in the directory /usr/local/taos/driver, and /usr/local/taos/driver is in the system library function search path LD_LIBRARY_PATH.
+8. For JDBC, ODBC, Python, Go, etc. connections on Windows, make sure that C:\ TDengine\ driver\ taos.dll is in your system library function search directory (it is recommended that taos.dll be placed in the directory C:\ Windows\ System32)
+9. If the connection issue still exist
+
+1. - On Linux system, please use the command line tool nc to determine whether the TCP and UDP connections on the specified ports are unobstructed. Check whether the UDP port connection works: nc -vuz {hostIP} {port} Check whether the server-side TCP port connection works: nc -l {port}Check whether the client-side TCP port connection works: nc {hostIP} {port}
+   - Windows systems use the PowerShell command Net-TestConnection-ComputerName {fqdn} Port {port} to detect whether the service-segment port is accessed
+
+10. You can also use the built-in network connectivity detection function of taos program to verify whether the specified port connection between the server and the client is unobstructed (including TCP and UDP): [TDengine's Built-in Network Detection Tool Use Guide](https://www.taosdata.com/blog/2020/09/08/1816.html).
+
+
+
+## 6.What to do if I encounter an error "Unexpected generic error in RPC" or "TDengine error: Unable to resolve FQDN"?
+
+This error occurs because the client or data node cannot parse the FQDN (Fully Qualified Domain Name). For TAOS shell or client applications, check the following:
+
+1. Please verify whether the FQDN of the connected server is correct. FQDN configuration reference: "[All about FQDN of TDengine](https://www.taosdata.com/blog/2020/09/11/1824.html)".
+2. If the network is configured with a DNS server, check that it is working properly.
+3. If the network does not have a DNS server configured, check the hosts file of the machine where the client is located to see if the FQDN is configured and has the correct IP address.
+4. If the network configuration is OK, from the machine where the client is located, you need to be able to ping the connected FQDN, otherwise the client cannot connect to the server
+
+## 7.Although the syntax is corrected, why do I still get the “Invalid SQL" error?
+
+If you confirm that the syntax is correct, for versions older than 2.0, please check whether the SQL statement length exceeds 64K. If it does, this error will also be returned.
+
+## 8. Are “validation queries” supported?
+
+The TDengine does not yet have a dedicated set of validation queries. However, it is recommended to use the database "log" monitored by the system.
+
+## 9. Can I delete or update a record?
+
+TDengine does not support the deletion function at present, and may support it in the future according to user requirements.
+
+Starting from 2.0. 8.0, TDengine supports the function of updating written data. Using the update function requires using UPDATE 1 parameter when creating the database, and then you can use INSERT INTO command to update the same timestamp data that has been written. UPDATE parameter does not support ALTER DATABASE command modification. Without a database created using UPDATE 1 parameter, writing data with the same timestamp will not modify the previous data with no error reported.
+
+It should also be noted that when UPDATE is set to 0, the data with the same timestamp sent later will be discarded directly, but no error will be reported, and will still be included in affected rows (so the return information of INSERT instruction cannot be used for timestamp duplicate checking). The main reason for this design is that TDengine regards the written data as a stream. Regardless of whether the timestamp conflicts or not, TDengine believes that the original device that generates the data actually generates such data. The UPDATE parameter only controls how such stream data should be processed when persistence-when UPDATE is 0, it means that the data written first overwrites the data written later; When UPDATE is 1, it means that the data written later overwrites the data written first. How to choose this coverage relationship depends on whether the data generated first or later is expected in the subsequent use and statistics compile.
+
+## 10. How to create a table with more than 1024 columns?
+
+Using version 2.0 and above, 1024 columns are supported by default; for older versions, TDengine allowed the creation of a table with a maximum of 250 columns. However, if the limit is exceeded, it is recommended to logically split this wide table into several small ones according to the data characteristics.
+
+## 11. What is the most effective way to write data?
+
+Insert in batches. Each write statement can insert multiple records into one or multiple tables at the same time.
+
+## 12. What is the most effective way to write data? How to solve the problem that Chinese characters in nchar inserted under Windows systems are parsed into messy code?
+
+If there are Chinese characters in nchar data under Windows, please first confirm that the region of the system is set to China (which can be set in the Control Panel), then the taos client in cmd should already support it normally; If you are developing Java applications in an IDE, such as Eclipse and Intellij, please confirm that the file code in the IDE is GBK (this is the default coding type of Java), and then initialize the configuration of the client when generating the Connection. The specific statement is as follows:
+
+```JAVA
+Class.forName("com.taosdata.jdbc.TSDBDriver");
+Properties properties = new Properties();
+properties.setProperty(TSDBDriver.LOCALE_KEY, "UTF-8");
+Connection = DriverManager.getConnection(url, properties);
+```
+
+## 13. JDBC error: the excluded SQL is not a DML or a DDL?
+
+Please update to the latest JDBC driver.
+
+```xml
+<dependency>
+  <groupId>com.taosdata.jdbc</groupId>
+  <artifactId>taos-jdbcdriver</artifactId>
+  <version>2.0.27</version>
+</dependency>
+```
+
+## 14. taos connect failed, reason: invalid timestamp.
+
+The common reason is that the server time and client time are not calibrated, which can be calibrated by synchronizing with the time server (use ntpdate command under Linux, and select automatic synchronization in the Windows time setting).
+
+## 15. Incomplete display of table name
+
+Due to the limited display width of taos shell in the terminal, it is possible that a relatively long table name is not displayed completely. If relevant operations are carried out according to the displayed incomplete table name, a Table does not exist error will occur. The workaround can be by modifying the setting option maxBinaryDisplayWidth in the taos.cfg file, or directly entering the command `set max_binary_display_width 100`. Or, use the \\G parameter at the end of the command to adjust how the results are displayed.
+
+## 16. How to migrate data?
+
+TDengine uniquely identifies a machine according to hostname. When moving data files from machine A to machine B, pay attention to the following three points:
+
+- For versions 2.0. 0.0 to 2.0. 6. x, reconfigure machine B's hostname to machine A's.
+- For 2.0. 7.0 and later versions, go to/var/lib/taos/dnode, repair the FQDN corresponding to dnodeId of dnodeEps.json, and restart. Make sure this file is identical for all machines.
+- The storage structures of versions 1. x and 2. x are incompatible, and it is necessary to use migration tools or your own application to export and import data.
+
+## 17. How to temporarily adjust the log level in command line program taos?
+
+For the convenience of debugging, since version 2.0. 16, command line program taos gets two new instructions related to logging:
+
+```mysql
+ALTER LOCAL flag_name flag_value;
+```
+
+This means that under the current command line program, modify the loglevel of a specific module (only valid for the current command line program, if taos is restarted, it needs to be reset):
+
+- The values of flag_name can be: debugFlag, cDebugFlag, tmrDebugFlag, uDebugFlag, rpcDebugFlag
+- Flag_value values can be: 131 (output error and alarm logs), 135 (output error, alarm, and debug logs), 143 (output error, alarm, debug, and trace logs)
+
+```mysql
+ALTER LOCAL RESETLOG;
+```
+
+This means wiping up all client-generated log files on the machine.
+