Docs/sangshuduo/td 13571 remove outdated (#10672)

* remove out-dated links

* refine taostools section

* adjst descriptions

* fix typo

* fix taosBenchmark doc link

* update documentation20/cn/02.getting-started/docs.md

* [TD-13571]<docs>: fix outdated

16KB => 64KB

* udpate schemaless section

documentation20/cn/05.insert/docs.md

@@ -35,7 +35,7 @@ INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31) (1538548695000, 12.6,
 
 **前言**
 <br/>在物联网应用中，常会采集比较多的数据项，用于实现智能控制、业务分析、设备监控等。由于应用逻辑的版本升级，或者设备自身的硬件调整等原因，数据采集项就有可能比较频繁地出现变动。为了在这种情况下方便地完成数据记录工作，TDengine 从 2.2.0.0 版本开始，提供调用 Schemaless 写入方式，可以免于预先创建超级表/子表的步骤，随着数据写入接口能够自动创建与数据对应的存储结构。并且在必要时，Schemaless 将自动增加必要的数据列，保证用户写入的数据可以被正确存储。
-<br/>目前，TDengine 的 C/C++ Connector 提供支持 Schemaless 的操作接口，详情请参见 [Schemaless 方式写入接口](https://www.taosdata.com/cn/documentation/connector#schemaless)章节。这里对 Schemaless 的数据表达格式进行了描述。
+<br/>目前，TDengine 的所有官方支持的连接器支持 Schemaless 的操作接口，详情请参见 [Schemaless 方式写入接口](https://www.taosdata.com/cn/documentation/connector#schemaless)章节。这里对 Schemaless 的数据表达格式进行了描述。
 <br/>无模式写入方式建立的超级表及其对应的子表与通过 SQL 直接建立的超级表和子表完全没有区别，您也可以通过 SQL 语句直接向其中写入数据。需要注意的是，通过无模式写入方式建立的表，其表名是基于标签值按照固定的映射规则生成，所以无法明确地进行表意，缺乏可读性。
 
 **无模式写入行协议**

documentation20/cn/08.connector/docs.md

@@ -2,7 +2,7 @@
 
 TDengine 提供了丰富的应用程序开发接口，其中包括 C/C++、Java、Python、Go、Node.js、C# 、RESTful 等，便于用户快速开发应用。
 
-![image-connecotr](../images/connector.png)
+![image-connector](../images/connector.png)
 
 目前 TDengine 的连接器可支持的平台广泛，包括：X64/X86/ARM64/ARM32/MIPS/Alpha 等硬件平台，以及 Linux/Win64/Win32 等开发环境。对照矩阵如下：
 
@@ -13,7 +13,7 @@ TDengine 提供了丰富的应用程序开发接口，其中包括 C/C++、Java
 | **JDBC**    | ●               | ●               | ●               | ○               | ●         | ●         | ○               | ○                | ○              |
 | **Python**  | ●               | ●               | ●               | ○               | ●         | ●         | ○               | --               | ○              |
 | **Go**      | ●               | ●               | ●               | ○               | ●         | ●         | ○               | --               | --             |
-| **NodeJs**  | ●               | ●               | ○               | ○               | ●         | ●         | ○               | --               | --             |
+| **Node.js**  | ●               | ●               | ○               | ○               | ●         | ●         | ○               | --               | --             |
 | **C#**      | ●               | ●               | ○               | ○               | ○         | ○         | ○               | --               | --             |
 | **RESTful** | ●               | ●               | ●               | ●               | ●         | ●         | ○               | ○                | ○              |
 
@@ -22,7 +22,7 @@ TDengine 提供了丰富的应用程序开发接口，其中包括 C/C++、Java
 注意：
 
 * 在没有安装 TDengine 服务端软件的系统中使用连接器（除 RESTful 外）访问 TDengine 数据库，需要安装相应版本的客户端安装包来使应用驱动（Linux 系统中文件名为 libtaos.so，Windows 系统中为 taos.dll）被安装在系统中，否则会产生无法找到相应库文件的错误。
-* 所有执行 SQL 语句的 API，例如 C/C++ Connector 中的 `tao_query`、`taos_query_a`、`taos_subscribe` 等，以及其它语言中与它们对应的 API，每次都只能执行一条 SQL 语句，如果实际参数中包含了多条语句，它们的行为是未定义的。
+* 所有执行 SQL 语句的 API，例如 C/C++ Connector 中的 `taos_query`、`taos_query_a`、`taos_subscribe` 等，以及其它语言中与它们对应的 API，每次都只能执行一条 SQL 语句，如果实际参数中包含了多条语句，它们的行为是未定义的。
 * 升级 TDengine 到 2.0.8.0 版本的用户，必须更新 JDBC。连接 TDengine 必须升级 taos-jdbcdriver 到 2.0.12 及以上。详细的版本依赖关系请参见 [taos-jdbcdriver 文档](https://www.taosdata.com/cn/documentation/connector/java#version)。
 * 无论选用何种编程语言的连接器，2.0 及以上版本的 TDengine 推荐数据库应用的每个线程都建立一个独立的连接，或基于线程建立连接池，以避免连接内的“USE statement”状态量在线程之间相互干扰（但连接的查询和写入操作都是线程安全的）。
 
@@ -434,9 +434,9 @@ typedef struct TAOS_MULTI_BIND {
       
   **说明**  
     协议类型是枚举类型，包含以下三种格式：  
-    TSDB_SML_LINE_PROTOCOL：InfluxDB行协议（Line Protocol)  
-    TSDB_SML_TELNET_PROTOCOL: OpenTSDB文本行协议  
-    TSDB_SML_JSON_PROTOCOL: OpenTSDB Json协议格式  
+    TSDB_SML_LINE_PROTOCOL：InfluxDB 行协议（Line Protocol)  
+    TSDB_SML_TELNET_PROTOCOL: OpenTSDB 文本行协议  
+    TSDB_SML_JSON_PROTOCOL: OpenTSDB JSON 协议格式  
     
     时间戳分辨率的定义，定义在 taos.h 文件中，具体内容如下：  
     TSDB_SML_TIMESTAMP_NOT_CONFIGURED = 0,  
@@ -451,7 +451,7 @@ typedef struct TAOS_MULTI_BIND {
     对于 OpenTSDB 的文本协议，时间戳的解析遵循其官方解析规则 — 按照时间戳包含的字符的数量来确认时间精度。
     
   **支持版本**  
-    该功能接口从2.3.0.0版本开始支持。
+    该功能接口从 2.3.0.0 版本开始支持。
 
 ```c
 #include <stdlib.h>

documentation20/en/05.insert/docs.md

@@ -4,7 +4,7 @@ TDengine supports multiple ways to write data, including SQL, Prometheus, Telegr
 
 ## <a class="anchor" id="sql"></a> Data Writing via SQL
 
-Applications insert data by executing SQL insert statements through C/C++, Java, Go, C#, Python, Node.js Connectors, 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:
+Applications insert data by executing SQL insert statements through C/C++, Java, Go, C#, Python, Node.js connectors, 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);
@@ -36,7 +36,7 @@ For the SQL INSERT Grammar, please refer to  [Taos SQL insert](https://www.taosd
 **Introduction**
 <br/> In many IoT applications, data collection is often used in intelligent control, business analysis and device monitoring etc. As fast application upgrade and iteration, or hardware adjustment, data collection metrics can change rapidly over time. To provide solutions to such use cases, from version 2.2.0.0, TDengine supports writing data via Schemaless. When using Schemaless, action of pre-creating table before inserting data is no longer needed anymore. Tables, data columns and tags can be created automatically. Schemaless can also add additional data columns to tables if necessary, to make sure data can be properly stored into TDengine.
 
-<br/> TDengine C/C++ Connector provides Schemaless API. Please see [Schemaless data writing API](https://www.taosdata.com/en/documentation/connector#schemaless) for detailed data writing format.
+<br/> TDengine's all official connectors provide Schemaless API now. Please see [Schemaless data writing API](https://www.taosdata.com/en/documentation/connector#schemaless) for detailed data writing format.
 <br/> Super table and corresponding child tables created via Schemaless are identical to the ones created via SQL, so inserting data into these tables via SQL is also supported. Note that child table names are generated via Schemaless are following special rules through tags mapping. Therefore, child table names are usually not meaningful in terms of readability.
 
 **Schemaless writing protocols**

documentation20/en/08.connector/docs.md

@@ -22,7 +22,7 @@ Note: ● stands for that has been verified by official tests; ○ stands for th
 Note:
 
 - To access the TDengine database through connectors (except RESTful) in the system without TDengine server software, it is necessary to install the corresponding version of the client installation package to make the application driver (the file name is libtaos.so in Linux system and taos.dll in Windows system) installed in the system, otherwise, the error that the corresponding library file cannot be found will occur.
-- All APIs that execute SQL statements, such as `tao_query()`, `taos_query_a()`, `taos_subscribe()` in C/C++ Connector, and APIs corresponding to them in other languages, can only execute one SQL statement at a time. If the actual parameters contain multiple statements, their behavior is undefined.
+- All APIs that execute SQL statements, such as `taos_query()`, `taos_query_a()`, `taos_subscribe()` in C/C++ connector, and APIs corresponding to them in other languages, can only execute one SQL statement at a time. If the actual parameters contain multiple statements, their behavior is undefined.
 - Users upgrading to TDengine 2.0. 8.0 must update the JDBC connection. TDengine must upgrade taos-jdbcdriver to 2.0.12 and above.
 - No matter which programming language connector is selected, TDengine version 2.0 and above recommends that each thread of database application establish an independent connection or establish a connection pool based on threads to avoid mutual interference between threads of "USE statement" state variables in the connection (but query and write operations of the connection are thread-safe).
 
@@ -347,6 +347,108 @@ Gets the result set of the statement. The result set is used in the same way as
 
 Execution completed, release all resources.
 
+- `char * taos_stmt_errstr(TAOS_STMT *stmt)`
+
+Gets the error message if any stmt API returns error.
+
+<a class="anchor" id="schemaless"></a>
+### Schemaless writing API
+
+In addition to writing data using SQL or using the parameter binding API, writing can also be done using Schemaless, which eliminates the need to create a super table/data sub-table data structure in advance and writes data directly, while the TDengine system automatically creates and maintains the required table structure based on the written data content. The use of Schemaless is described in the Schemaless Writing section, and the C/C++ API used with it is described here.
+
+- `TAOS_RES* taos_schemaless_insert(TAOS* taos, const char* lines[], int numLines, int protocol, int precision)`
+
+  **Function Description**
+
+  This interface writes the text data of the line protocol to TDengine.
+
+  **Parameter Description**
+
+  taos: database connection, the database connection established by taos_connect function.
+
+  lines: text data. A pattern-free text string that meets the parsing format requirements.
+
+  numLines: the number of lines of the text data, cannot be 0.
+
+  protocol: the protocol type of the lines, used to identify the format of the text data.
+
+  precision: precision string of the timestamp in the text data.
+
+  **Return Value**
+
+  TAOS_RES structure, the application can get the error message by using taos_errstr and also get the error code by using taos_errno.
+
+  In some cases, the returned TAOS_RES is NULL, in which case taos_errno can still be called to safely get the error code information.
+
+  The returned TAOS_RES needs to be freed by the caller, otherwise a memory leak will occur.
+
+  **Description**
+
+  The protocol type is enumerated and contains the following three formats.
+
+  TSDB_SML_LINE_PROTOCOL: InfluxDB line protocol (Line Protocol)
+
+  TSDB_SML_TELNET_PROTOCOL: OpenTSDB Text Line Protocol
+
+  TSDB_SML_JSON_PROTOCOL: OpenTSDB JSON protocol format
+
+  The timestamp resolution is defined in the taos.h file, as follows
+
+  TSDB_SML_TIMESTAMP_NOT_CONFIGURED = 0,
+
+  TSDB_SML_TIMESTAMP_HOURS,
+
+  TSDB_SML_TIMESTAMP_MINUTES,
+
+  TSDB_SML_TIMESTAMP_SECONDS,
+
+  TSDB_SML_TIMESTAMP_MILLI_SECONDS,
+
+  TSDB_SML_TIMESTAMP_MICRO_SECONDS,
+
+  TSDB_SML_TIMESTAMP_NANO_SECONDS
+
+  Note that the timestamp resolution parameter only takes effect when the protocol type is SML_LINE_PROTOCOL.
+
+  For OpenTSDB text protocols, the timestamp resolution follows the official resolution rules - the time precision is determined by the number of characters contained in the timestamp.
+
+  **Supported versions**
+
+  This functional interface is supported since version 2.3.0.0.
+
+```c
+#include <stdlib.h>
+#include <stdio.h>
+#include <taos.h>
+ 
+int main() {
+  const char* host = "127.0.0.1";
+  const char* user = "root";
+  const char* passwd = "taosdata";
+
+  // connect to server
+  TAOS* taos = taos_connect(host, user, passwd, "test", 0);
+   
+  // prepare the line string
+  char* lines1[] = {
+      "stg,t1=3i64,t2=4f64,t3=\"t3\" c1=3i64,c3=L\"passit\",c2=false,c4=4f64 1626006833639000000",
+      "stg,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin\",c2=true,c4=5f64,c5=5f64 1626006833641000000"
+  };
+ 
+  // schema-less insert
+  TAOS_RES* res = taos_schemaless_insert(taos, lines1, 2, TSDB_SML_LINE_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS);
+  if (taos_errno(res) != 0) {
+    printf("failed to insert schema-less data, reason: %s\n", taos_errstr(res));
+  }
+ 
+  taos_free_result(res);
+ 
+  // close the connection
+  taos_close(taos);
+  return (code);
+}
+```
+
 ### Continuous query interface
 
 TDengine provides time-driven real-time stream computing APIs. You can perform various real-time aggregation calculation operations on tables (data streams) of one or more databases at regular intervals. The operation is simple, only APIs for opening and closing streams. The details are as follows: