Merge pull request #11068 from taosdata/docs/dingbo/TD-13605-schemaless

java and python schemaless exmaples

docs-cn/06-insert-data/01-sql-writing.mdx

@@ -118,6 +118,6 @@ TDengine 也提供了支持参数绑定的 Prepare API，与 MySQL 一样，这
 
 :::note
 
-只有使用本地驱动方式连接连接，才能使用动态绑定功能。
+只有使用本地驱动方式建立连接，才能使用动态绑定功能。
 
 :::

docs-cn/06-insert-data/_java_line.mdx

+```java
+{{#include docs-examples/java/src/main/java/com/taos/example/LineProtocolExample.java}}
+```

docs-cn/06-insert-data/_java_opts_json.mdx

+```java
+{{#include docs-examples/java/src/main/java/com/taos/example/JSONProtocolExample.java}}
+```

docs-cn/06-insert-data/_java_opts_telnet.mdx

+```java
+{{#include docs-examples/java/src/main/java/com/taos/example/TelnetLineProtocolExample.java}}
+```

docs-cn/06-insert-data/_py_line.mdx

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

docs-cn/06-insert-data/_py_opts_json.mdx

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

docs-cn/06-insert-data/_py_opts_telnet.mdx

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

docs-cn/06-insert-data/_py_sql.mdx

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

docs-cn/06-insert-data/_py_stmt.mdx

+```py
+{{#include docs-examples/python/bind_param_example.py}}
+```
\ No newline at end of file

docs-cn/07-query-data/_py.mdx

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

docs-cn/07-query-data/_py_async.mdx

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

docs-cn/14-reference/03-connector/cshapr.mdx → docs-cn/14-reference/03-connector/csharp.mdx

@@ -7,15 +7,15 @@ sidebar_label: C#
 
 - C# 连接器支持的系统有：Linux 64/Windows x64/Windows x86
 
-- C# 连接器现在也支持从[Nuget 下载引用](https://www.nuget.org/packages/TDengine.Connector/)
+- C# 连接器现在也支持从 [Nuget 下载引用](https://www.nuget.org/packages/TDengine.Connector/)
 
 - 在 Windows 系统上，C# 应用程序可以使用 TDengine 的原生 C 接口来执行所有数据库操作，后续版本将提供 ORM（Dapper）框架驱动。
 
 ## 安装准备
 
-- 应用驱动安装请参考[安装连接器驱动步骤](https://www.taosdata.com/cn/documentation/connector#driver)。
-- 接口文件 TDengineDrivercs.cs 和参考程序示例 TDengineTest.cs 均位于 Windows 客户端 install_directory/examples/C#目录下。
-- 安装[.NET SDK](https://dotnet.microsoft.com/download)
+- 应用驱动安装请参考[安装连接器驱动步骤](/reference/connector/#安装客户端驱动)。
+- 接口文件 TDengineDrivercs.cs 和参考程序示例 TDengineTest.cs 均位于 Windows 客户端 install_directory/examples/C# 目录下。
+- 安装 [.NET SDK](https://dotnet.microsoft.com/download)
 
 ## 示例程序
 

docs-cn/14-reference/03-connector/java.mdx

@@ -357,7 +357,7 @@ JDBC 连接器可能报错的错误码包括 3 种：JDBC driver 本身的报错
 - https://github.com/taosdata/TDengine/blob/develop/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBErrorNumbers.java
 - https://github.com/taosdata/TDengine/blob/develop/src/inc/taoserror.h
 
-### <a class="anchor" id="stmt-java"></a>通过参数绑定写入数据
+### 通过参数绑定写入数据
 
 从 2.1.2.0 版本开始，TDengine 的 JDBC-JNI 实现大幅改进了参数绑定方式对数据写入（INSERT）场景的支持。采用这种方式写入数据时，能避免 SQL 语法解析的资源消耗，从而在很多情况下显著提升写入性能。
 注意：
@@ -626,7 +626,47 @@ public void setString(int columnIndex, ArrayList<String> list, int size) throws
 public void setNString(int columnIndex, ArrayList<String> list, int size) throws SQLException
 ```
 
-### <a class="anchor" id="set-client-configuration"></a>设置客户端参数
+### 无模式写入
+
+从 2.2.0.0 版本开始，TDengine 增加了对无模式写入功能。无模式写入兼容 InfluxDB 的 行协议（Line Protocol）、OpenTSDB 的 telnet 行协议和 OpenTSDB 的 JSON 格式协议。详情请参见[无模式写入](https://www.taosdata.com/docs/cn/v2.0/insert#schemaless)。
+
+注意：
+
+- JDBC-RESTful 实现并不提供无模式写入这种使用方式
+- 以下示例代码基于 taos-jdbcdriver-2.0.36
+
+示例代码：
+
+```java
+public class SchemalessInsertTest {
+    private static final String host = "127.0.0.1";
+    private static final String lineDemo = "st,t1=3i64,t2=4f64,t3=\"t3\" c1=3i64,c3=L\"passit\",c2=false,c4=4f64 1626006833639000000";
+    private static final String telnetDemo = "stb0_0 1626006833 4 host=host0 interface=eth0";
+    private static final String jsonDemo = "{\"metric\": \"meter_current\",\"timestamp\": 1346846400,\"value\": 10.3, \"tags\": {\"groupid\": 2, \"location\": \"Beijing\", \"id\": \"d1001\"}}";
+
+    public static void main(String[] args) throws SQLException {
+        final String url = "jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata";
+        try (Connection connection = DriverManager.getConnection(url)) {
+            init(connection);
+
+            SchemalessWriter writer = new SchemalessWriter(connection);
+            writer.write(lineDemo, SchemalessProtocolType.LINE, SchemalessTimestampType.NANO_SECONDS);
+            writer.write(telnetDemo, SchemalessProtocolType.TELNET, SchemalessTimestampType.MILLI_SECONDS);
+            writer.write(jsonDemo, SchemalessProtocolType.JSON, SchemalessTimestampType.NOT_CONFIGURED);
+        }
+    }
+
+    private static void init(Connection connection) throws SQLException {
+        try (Statement stmt = connection.createStatement()) {
+            stmt.executeUpdate("drop database if exists test_schemaless");
+            stmt.executeUpdate("create database if not exists test_schemaless");
+            stmt.executeUpdate("use test_schemaless");
+        }
+    }
+}
+```
+
+### 设置客户端参数
 
 从 TDengine-2.3.5.0 版本开始，jdbc driver 支持在应用的第一次连接中，设置 TDengine 的客户端参数。Driver 支持 JDBC-JNI 方式中，通过 jdbcUrl 和 properties 两种方式设置 client parameter。
 注意：
@@ -687,7 +727,7 @@ public class ClientParameterSetting {
 }
 ```
 
-## <a class="anchor" id="subscribe"></a>订阅
+## 订阅
 
 ### 创建
 

docs-cn/14-reference/03-connector/node.mdx

@@ -15,7 +15,7 @@ Node.js 连接器的使用参见[视频教程](https://www.taosdata.com/blog/202
 
 ### 安装准备
 
-- 应用驱动安装请参考[安装连接器驱动步骤](https://www.taosdata.com/cn/documentation/connector#driver)。
+- 应用驱动安装请参考[安装连接器驱动步骤](/reference/connector/#安装客户端驱动)。
 
 ### 安装 Node.js 连接器
 

docs-cn/14-reference/03-connector/python.mdx

@@ -15,7 +15,7 @@ Python 连接器支持的系统有：Linux 64/Windows x64
 
 安装前准备：
 
-- 已安装好 TDengine 应用驱动，请参考[安装连接器驱动步骤](https://www.taosdata.com/cn/documentation/connector#driver)
+- 已安装好 TDengine 应用驱动，请参考[安装连接器驱动步骤](/reference/connector/#安装客户端驱动)
 - 已安装 python 2.7 or >= 3.4
 - 已安装 pip
 
@@ -281,75 +281,3 @@ k1 = conn.query("select info->'k1' as k1 from s1").fetch_all_into_dict()
 - _connect_ 方法
 
   用于生成 taos.TaosConnection 的实例。
-
-## <a class="anchor" id="restful"></a>RESTful Connector
-
-为支持各种不同类型平台的开发，TDengine 提供符合 REST 设计标准的 API，即 RESTful API。为最大程度降低学习成本，不同于其他数据库 RESTful API 的设计方法，TDengine 直接通过 HTTP POST 请求 BODY 中包含的 SQL 语句来操作数据库，仅需要一个 URL。RESTful 连接器的使用参见[视频教程](https://www.taosdata.com/blog/2020/11/11/1965.html)。
-
-注意：与原生连接器的一个区别是，RESTful 接口是无状态的，因此 `USE db_name` 指令没有效果，所有对表名、超级表名的引用都需要指定数据库名前缀。（从 2.2.0.0 版本开始，支持在 RESTful url 中指定 db_name，这时如果 SQL 语句中没有指定数据库名前缀的话，会使用 url 中指定的这个 db_name。从 2.4.0.0 版本开始，RESTful 默认有 taosAdapter 提供，要求必须在 url 中指定 db_name。）
-
-### 安装
-
-RESTful 接口不依赖于任何 TDengine 的库，因此客户端不需要安装任何 TDengine 的库，只要客户端的开发语言支持 HTTP 协议即可。
-
-### 验证
-
-在已经安装 TDengine 服务器端的情况下，可以按照如下方式进行验证。
-
-下面以 Ubuntu 环境中使用 curl 工具（确认已经安装）来验证 RESTful 接口的正常。
-
-下面示例是列出所有的数据库，请把 h1.taosdata.com 和 6041（缺省值）替换为实际运行的 TDengine 服务 fqdn 和端口号：
-
-```html
-curl -H 'Authorization: Basic cm9vdDp0YW9zZGF0YQ==' -d 'show databases;'
-h1.taosdata.com:6041/rest/sql
-```
-
-返回值结果如下表示验证通过：
-
-```json
-{
-  "status": "succ",
-  "head": [
-    "name",
-    "created_time",
-    "ntables",
-    "vgroups",
-    "replica",
-    "quorum",
-    "days",
-    "keep1,keep2,keep(D)",
-    "cache(MB)",
-    "blocks",
-    "minrows",
-    "maxrows",
-    "wallevel",
-    "fsync",
-    "comp",
-    "precision",
-    "status"
-  ],
-  "data": [
-    [
-      "log",
-      "2020-09-02 17:23:00.039",
-      4,
-      1,
-      1,
-      1,
-      10,
-      "30,30,30",
-      1,
-      3,
-      100,
-      4096,
-      1,
-      3000,
-      2,
-      "us",
-      "ready"
-    ]
-  ],
-  "rows": 1
-}
-```

docs-cn/14-reference/13-schemaless/13-schemaless.md

@@ -6,7 +6,6 @@
 从 2.2.0.0 版本开始，提供调用 Schemaless 写入方式，可以免于预先创建超级表/子表的步骤，随着数据写入接口能够自动创建与数据对应的存储结构。并且在必要时，Schemaless
 将自动增加必要的数据列，保证用户写入的数据可以被正确存储。
 
-
 无模式写入方式建立的超级表及其对应的子表与通过 SQL 直接建立的超级表和子表完全没有区别，你也可以通过，SQL 语句直接向其中写入数据。需要注意的是，通过无模式写入方式建立的表，其表名是基于标签值按照固定的映射规则生成，所以无法明确地进行表意，缺乏可读性。
 
 ## 无模式写入行协议
@@ -80,9 +79,10 @@ st,t1=3,t2=4,t3=t3 c1=3i64,c3="passit",c2=false,c4=4f64 1626006833639000000
 7. 如果指定的数据子表已经存在，而且本次指定的标签列取值跟已保存的值不一样，那么最新的数据行中的值会覆盖旧的标签列取值。
 8. 整个处理过程中遇到的错误会中断写入过程，并返回错误代码。
 
-:::Tip
+:::tip
 无模式所有的处理逻辑，仍会遵循 TDengine 对数据结构的底层限制，例如每行数据的总长度不能超过
 16k 字节。这方面的具体限制约束请参见 [TAOS SQL 边界限制](https://www.taosdata.com/cn/documentation/taos-sql#limitation)
+
 :::
 
 ## 时间分辨率识别
@@ -161,4 +161,4 @@ TDengine 提供数据写入的幂等性保证，即您可以反复调用 API 进
 
 如果是无模式写入过程中的数据本身错误，应用会得到 TSDB_CODE_TSC_LINE_SYNTAX_ERROR
 错误信息，该错误信息表明错误发生在写入文本中。其他的错误码与原系统一致，可以通过
-taos_errstr 获取具体的错误原因。
\ No newline at end of file
+taos_errstr 获取具体的错误原因。

docs-examples/c/.gitignore

+*
+!*.c
+!.gitignore

docs-examples/c/json_protocol_example.c

+// compile with
+// gcc connect_example.c -o connect_example -I /usr/local/taos/include -L /usr/local/taos/driver -ltaos
+#include <stdio.h>
+#include "taos.h"
+#include "taoserror.h"
+
+int main() {
+  // if don't want to connect to a default db, set it to NULL.
+  const char *db = "test";
+  TAOS       *taos = taos_connect("localhost", "root", "taosdata", db, 6030);
+  printf("Connected\n");
+  char *message[] = {
+"[                                       \
+  {                                      \
+     \"metric\":\"cpu_load_1\",          \
+     \"timestamp\": 1626006833,    \
+     \"value\": 55.5,                    \
+     \"tags\":                           \
+         {                               \
+             \"host\": \"ubuntu\",       \
+             \"interface\": \"eth1\",    \
+             \"Id\": \"tb1\"             \
+         }                               \
+  },                                     \
+  {                                      \
+     \"metric\":\"cpu_load_2\",          \
+     \"timestamp\": 1626006833,    \
+     \"value\": 55.5,                    \
+     \"tags\":                           \
+         {                               \
+             \"host\": \"ubuntu\",       \
+             \"interface\": \"eth2\",    \
+             \"Id\": \"tb2\"             \
+         }                               \
+  }                                      \
+ ]",
+ "[                                       \
+  {                                      \
+     \"metric\":\"cpu_load_1\",          \
+     \"timestamp\": 1626006834,    \
+     \"value\": 56.5,                    \
+     \"tags\":                           \
+         {                               \
+             \"host\": \"ubuntu\",       \
+             \"interface\": \"eth1\",    \
+             \"Id\": \"tb1\"             \
+         }                               \
+  },                                     \
+  {                                      \
+     \"metric\":\"cpu_load_2\",          \
+     \"timestamp\": 1626006834,    \
+     \"value\": 56.5,                    \
+     \"tags\":                           \
+         {                               \
+             \"host\": \"ubuntu\",       \
+             \"interface\": \"eth2\",    \
+             \"Id\": \"tb2\"             \
+         }                               \
+  }                                      \
+ ]"
+ };
+void*  code = taos_schemaless_insert(taos, message, 1, 3, NULL);
+if (code) {
+  printf("payload_1 code: %d, %s.\n", code, tstrerror(code));
+}
+  taos_close(taos);
+}

docs-examples/csharp/ConnectExample.cs

 
-namespace TDExamples
+
+namespace TDengineExample
 {
-     internal class ConnectExample
+    using TDengineDriver;
+
+    internal class ConnectExample
     {
         static void Main(String[] args)
         {  

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

+package com.taos.example;
+
+public class JSONProtocolExample {
+
+}

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=Beijing.Chaoyang,groupid=2 current=10.3,voltage=219,phase=0.31 1648432611249300", // micro seconds
+            "meters,location=Beijing.Chaoyang,groupid=2 current=12.6,voltage=218,phase=0.33 1648432611249800",
+            "meters,location=Beijing.Chaoyang,groupid=2 current=12.3,voltage=221,phase=0.31 1648432611250300",
+            "meters,location=Beijing.Chaoyang,groupid=3 current=10.3,voltage=218,phase=0.25 1648432611249200",
+            "meters,location=Beijing.Haidian,groupid=2 current=11.8,voltage=221,phase=0.28 1648432611249000",
+            "meters,location=Beijing.Haidian,groupid=2 current=13.4,voltage=223,phase=0.29 1648432611249500",
+            "meters,location=Beijing.Haidian,groupid=3 current=10.8,voltage=223,phase=0.29 1648432611249300",
+            "meters,location=Beijing.Haidian,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 (microsecond), but we use us(microsecond) here.
+            stmt.execute("create database 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/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=Beijing.Chaoyang groupid=2",
+            "meters.current 1648432611250 12.6 location=Beijing.Chaoyang groupid=2",
+            "meters.current 1648432611249 10.8 location=Beijing.Haidian groupid=3",
+            "meters.current 1648432611250 11.3 location=Beijing.Haidian groupid=3",
+            "meters.voltage 1648432611249 219 location=Beijing.Chaoyang groupid=2",
+            "meters.voltage 1648432611250 218 location=Beijing.Chaoyang groupid=2",
+            "meters.voltage 1648432611249 221 location=Beijing.Haidian groupid=3",
+            "meters.voltage 1648432611250 217 location=Beijing.Haidian 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 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/python/async_query_example.py

+import taos
\ No newline at end of file

docs-examples/python/bind_param_example.py

+import taos
\ No newline at end of file

docs-examples/python/json_protocol_example.py

+import json
+
+import taos
+from taos import SmlProtocol, SmlPrecision
+
+lines = [[{"metric": "meters.current", "timestamp": 1648432611249, "value": 10.3, "tags": {"location": "Beijing.Chaoyang", "groupid": 2}},
+          {"metric": "meters.voltage", "timestamp": 1648432611249, "value": 219, "tags": {"location": "Beijing.Haidian", "groupid": 1}}],
+         [{"metric": "meters.current", "timestamp": 1648432611250, "value": 12.6, "tags": {"location": "Beijing.Chaoyang", "groupid": 2}},
+          {"metric": "meters.voltage", "timestamp": 1648432611250, "value": 221, "tags": {"location": "Beijing.Haidian", "groupid": 1}}]
+         ]
+
+
+def get_connection():
+    # create connection use firstEp in taos.cfg.
+    return taos.connect()
+
+
+def create_database(conn):
+    conn.execute("create database test")
+    conn.execute("use test")
+
+
+def insert_lines(conn):
+    global lines
+    lines = [json.dumps(line) for line in lines]
+    print(lines)
+    affected_rows = conn.schemaless_insert(lines, SmlProtocol.JSON_PROTOCOL, SmlPrecision.NOT_CONFIGURED)
+    print(affected_rows)  # 这里有 bug, 4 条数据只写入 2 条。
+
+
+if __name__ == '__main__':
+    connection = get_connection()
+    create_database(connection)
+    insert_lines(connection)
+    connection.close()

docs-examples/python/line_protocol_example.py

+import taos
+from taos import SmlProtocol, SmlPrecision
+
+lines = ["meters,location=Beijing.Chaoyang,groupid=2 current=10.3,voltage=219,phase=0.31 1648432611249300",
+         "meters,location=Beijing.Chaoyang,groupid=2 current=12.6,voltage=218,phase=0.33 1648432611249800",
+         "meters,location=Beijing.Chaoyang,groupid=2 current=12.3,voltage=221,phase=0.31 1648432611250300",
+         "meters,location=Beijing.Chaoyang,groupid=3 current=10.3,voltage=218,phase=0.25 1648432611249200",
+         "meters,location=Beijing.Haidian,groupid=2 current=11.8,voltage=221,phase=0.28 1648432611249000",
+         "meters,location=Beijing.Haidian,groupid=2 current=13.4,voltage=223,phase=0.29 1648432611249500",
+         "meters,location=Beijing.Haidian,groupid=3 current=10.8,voltage=223,phase=0.29 1648432611249300",
+         "meters,location=Beijing.Haidian,groupid=3 current=11.3,voltage=221,phase=0.35 1648432611249800",
+         ]
+
+
+def get_connection():
+    # create connection use firstEP in taos.cfg.
+    return taos.connect()
+
+
+def create_database(conn):
+    # the default precision is ms (microsecond), but we use us(microsecond) here.
+    conn.execute("create database test precision 'us'")
+    conn.execute("use test")
+
+
+def insert_lines(conn):
+    affected_rows = conn.schemaless_insert(lines, SmlProtocol.LINE_PROTOCOL, SmlPrecision.MICRO_SECONDS)
+    print(affected_rows)  # 8
+
+
+if __name__ == '__main__':
+    connection = get_connection()
+    create_database(connection)
+    insert_lines(connection)
+    connection.close()

docs-examples/python/native_insert_example.py

+import taos
\ No newline at end of file

docs-examples/python/query_example.py

+import taos
+
+conn = taos.connect()
+
+
+def print_all():
+    result = conn.query()

docs-examples/python/telnet_line_protocol_example.py

+import taos
+from taos import SmlProtocol, SmlPrecision
+
+# format: <metric> <timestamp> <value> <tagk_1>=<tagv_1>[ <tagk_n>=<tagv_n>]
+lines = ["meters.current 1648432611249 10.3 location=Beijing.Chaoyang groupid=2",
+         "meters.current 1648432611250 12.6 location=Beijing.Chaoyang groupid=2",
+         "meters.current 1648432611249 10.8 location=Beijing.Haidian groupid=3",
+         "meters.current 1648432611250 11.3 location=Beijing.Haidian groupid=3",
+         "meters.voltage 1648432611249 219 location=Beijing.Chaoyang groupid=2",
+         "meters.voltage 1648432611250 218 location=Beijing.Chaoyang groupid=2",
+         "meters.voltage 1648432611249 221 location=Beijing.Haidian groupid=3",
+         "meters.voltage 1648432611250 217 location=Beijing.Haidian groupid=3",
+         ]
+
+
+# create connection use firstEp in taos.cfg.
+def get_connection():
+    return taos.connect()
+
+
+def create_database(conn):
+    conn.execute("create database test")
+    conn.execute("use test")
+
+
+def insert_lines(conn):
+    affected_rows = conn.schemaless_insert(lines, SmlProtocol.TELNET_PROTOCOL, SmlPrecision.NOT_CONFIGURED)
+    print(affected_rows)  # 8
+
+
+if __name__ == '__main__':
+    connection = get_connection()
+    create_database(connection)
+    insert_lines(connection)
+    connection.close()