diff --git a/documentation20/cn/05.insert/docs.md b/documentation20/cn/05.insert/docs.md
index f055b0c25ba4811336084d6a2a58d6752b9db1e5..92b60be27cd6a4ff3bfa15c99a669f9503a2b902 100644
--- a/documentation20/cn/05.insert/docs.md
+++ b/documentation20/cn/05.insert/docs.md
@@ -2,7 +2,7 @@
TDengine支持多种接口写入数据，包括SQL, Prometheus, Telegraf, EMQ MQTT Broker, HiveMQ Broker, CSV文件等，后续还将提供Kafka, OPC等接口。数据可以单条插入，也可以批量插入，可以插入一个数据采集点的数据，也可以同时插入多个数据采集点的数据。支持多线程插入，支持时间乱序数据插入，也支持历史数据插入。
-## SQL写入
+## SQL 写入
应用通过C/C++、JDBC、GO、C#或Python Connector 执行SQL insert语句来插入数据，用户还可以通过TAOS Shell，手动输入SQL insert语句插入数据。比如下面这条insert 就将一条记录写入到表d1001中：
```mysql
@@ -27,11 +27,73 @@ INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31) (1538548695000, 12.6,
- 对同一张表，如果新插入记录的时间戳已经存在，默认情形下（UPDATE=0）新记录将被直接抛弃，也就是说，在一张表里，时间戳必须是唯一的。如果应用自动生成记录，很有可能生成的时间戳是一样的，这样，成功插入的记录条数会小于应用插入的记录条数。如果在创建数据库时使用了 UPDATE 1 选项，插入相同时间戳的新记录将覆盖原有记录。
- 写入的数据的时间戳必须大于当前时间减去配置参数keep的时间。如果keep配置为3650天，那么无法写入比3650天还早的数据。写入数据的时间戳也不能大于当前时间加配置参数days。如果days为2，那么无法写入比当前时间还晚2天的数据。
-## Prometheus直接写入
+## Schemaless 写入
+
+在物联网应用中，常会采集比较多的数据项，用于实现智能控制、业务分析、设备监控等。由于应用逻辑的版本升级，或者设备自身的硬件调整等原因，数据采集项就有可能比较频繁地出现变动。为了在这种情况下方便地完成数据记录工作，TDengine 从 2.2.0.0 版本开始，提供 Schemaless 写入方式，可以免于预先创建超级表/数据子表，而是随着数据写入，自动创建与数据对应的存储结构。并且在必要时，Schemaless 将自动增加必要的数据列，保证用户写入的数据可以被正确存储。目前，TDengine 的 C/C++ Connector 提供支持 Schemaless 的操作接口，详情请参见 [Schemaless 方式写入接口](https://www.taosdata.com/cn/documentation/connector#schemaless) 章节。这里对 Schemaless 的数据表达格式进行描述。
+
+### Schemaless 数据行协议
+
+Schemaless 采用一个字符串来表达最终存储的一个数据行（可以向 Schemaless 写入 API 中一次传入多个字符串来实现多个数据行的批量写入），其格式约定如下：
+```json
+measurement,tag_set field_set timestamp
+```
+
+其中，
+* measurement 将作为数据表名。它与 tag_set 之间使用一个英文逗号来分隔。
+* tag_set 将作为标签数据，其格式形如 `=,=`，也即可以使用英文逗号来分隔多个标签数据。它与 field_set 之间使用一个半角空格来分隔。
+* field_set 将作为普通列数据，其格式形如 `=,=`，同样是使用英文逗号来分隔多个普通列的数据。它与 timestamp 之间使用一个半角空格来分隔。
+* timestamp 即本行数据对应的主键时间戳。
+
+在 Schemaless 的数据行协议中，tag_set、field_set 中的每个数据项都需要对自身的数据类型进行描述。具体来说：
+* 如果两边有英文双引号，表示 BIANRY(32) 类型。例如 `"abc"`。
+* 如果两边有英文双引号而且带有 L 前缀，表示 NCHAR(32) 类型。例如 `L"报错信息"`。
+* 对空格、等号（=）、逗号（,）、双引号（"），前面需要使用反斜杠（\）进行转义。（都指的是英文半角符号）
+* 数值类型将通过后缀来区分数据类型：
+ - 没有后缀，为 FLOAT 类型；
+ - 后缀为 f32，为 FLOAT 类型；
+ - 后缀为 f64，为 DOUBLE 类型；
+ - 后缀为 i8，表示为 TINYINT (INT8) 类型；
+ - 后缀为 i16，表示为 SMALLINT (INT16) 类型；
+ - 后缀为 i32，表示为 INT (INT32) 类型；
+ - 后缀为 i64，表示为 BIGINT (INT64) 类型；
+ - 后缀为 b，表示为 BOOL 类型。
+* t, T, true, True, TRUE, f, F, false, False 将直接作为 BOOL 型来处理。
+
+timestamp 位置的时间戳通过后缀来声明时间精度，具体如下：
+* 不带任何后缀的长整数会被当作微秒来处理；
+* 当后缀为 s 时，表示秒时间戳；
+* 当后缀为 ms 时，表示毫秒时间戳；
+* 当后缀为 us 时，表示微秒时间戳；
+* 当后缀为 ns 时，表示纳秒时间戳；
+* 当时间戳为 0 时，表示采用客户端的当前时间（因此，同一批提交的数据中，时间戳 0 会被解释为同一个时间点，于是就有可能导致时间戳重复）。
+
+例如，如下 Schemaless 数据行表示：向名为 st 的超级表下的 t1 标签为 3（BIGINT 类型）、t2 标签为 4（DOUBLE 类型）、t3 标签为 "t3"（BINARY 类型）的数据子表，写入 c1 列为 3（BIGINT 类型）、c2 列为 false（BOOL 类型）、c3 列为 "passit"（NCHAR 类型）、c4 列为 4（DOUBLE 类型）、主键时间戳为 1626006833639000000（纳秒精度）的一行数据。
+```json
+st,t1=3i64,t2=4f64,t3="t3" c1=3i64,c3=L"passit",c2=false,c4=4f64 1626006833639000000ns
+```
+
+### Schemaless 的处理逻辑
+
+Schemaless 按照如下原则来处理行数据：
+1. 当 tag_set 中有 ID 字段时，该字段的值将作为数据子表的表名。
+2. 没有 ID 字段时，将使用 `measurement + tag_value1 + tag_value2 + ...` 的 md5 值来作为子表名。
+3. 如果指定的超级表名不存在，则 Schemaless 会创建这个超级表。
+4. 如果指定的数据子表不存在，则 Schemaless 会使用 tag values 创建这个数据子表。
+5. 如果数据行中指定的标签列或普通列不存在，则 Schemaless 会在超级表中增加对应的标签列或普通列（只增不减）。
+6. 如果超级表中存在一些标签列或普通列未在一个数据行中被指定取值，那么这些列的值在这一行中会被置为 NULL。
+7. 对 BINARY 或 NCHAR 列，如果数据行中所提供值的长度超出了列类型的限制，那么 Schemaless 会增加该列允许存储的字符长度上限（只增不减），以保证数据的完整保存。
+8. 如果指定的数据子表已经存在，而且本次指定的标签列取值跟已保存的值不一样，那么最新的数据行中的值会覆盖旧的标签列取值。
+9. 整个处理过程中遇到的错误会中断写入过程，并返回错误代码。
+
+**注意：**Schemaless 所有的处理逻辑，仍会遵循 TDengine 对数据结构的底层限制，例如每行数据的总长度不能超过 16k 字节。这方面的具体限制约束请参见 [TAOS SQL 边界限制](https://www.taosdata.com/cn/documentation/taos-sql#limitation) 章节。
+
+关于 Schemaless 的字符串编码处理、时区设置等，均会沿用 TAOSC 客户端的设置。
+
+## Prometheus 直接写入
[Prometheus](https://www.prometheus.io/)作为Cloud Native Computing Fundation毕业的项目，在性能监控以及K8S性能监控领域有着非常广泛的应用。TDengine提供一个小工具[Bailongma](https://github.com/taosdata/Bailongma)，只需对Prometheus做简单配置，无需任何代码，就可将Prometheus采集的数据直接写入TDengine，并按规则在TDengine自动创建库和相关表项。博文[用Docker容器快速搭建一个Devops监控Demo](https://www.taosdata.com/blog/2020/02/03/1189.html)即是采用Bailongma将Prometheus和Telegraf的数据写入TDengine中的示例，可以参考。
-### 从源代码编译blm_prometheus
+### 从源代码编译 blm_prometheus
用户需要从github下载[Bailongma](https://github.com/taosdata/Bailongma)的源码，使用Golang语言编译器编译生成可执行文件。在开始编译前，需要准备好以下条件：
- Linux操作系统的服务器
@@ -46,11 +108,11 @@ go build
一切正常的情况下，就会在对应的目录下生成一个blm_prometheus的可执行程序。
-### 安装Prometheus
+### 安装 Prometheus
通过Prometheus的官网下载安装。具体请见：[下载地址](https://prometheus.io/download/)。
-### 配置Prometheus
+### 配置 Prometheus
参考Prometheus的[配置文档](https://prometheus.io/docs/prometheus/latest/configuration/configuration/)，在Prometheus的配置文件中的部分，增加以下配置：
@@ -60,7 +122,8 @@ go build
启动Prometheus后，可以通过taos客户端查询确认数据是否成功写入。
-### 启动blm_prometheus程序
+### 启动 blm_prometheus 程序
+
blm_prometheus程序有以下选项，在启动blm_prometheus程序时可以通过设定这些选项来设定blm_prometheus的配置。
```bash
--tdengine-name
@@ -94,7 +157,8 @@ remote_write:
- url: "http://10.1.2.3:8088/receive"
```
-### 查询prometheus写入数据
+### 查询 prometheus 写入数据
+
prometheus产生的数据格式如下：
```json
{
@@ -105,10 +169,10 @@ prometheus产生的数据格式如下：
instance="192.168.99.116:8443",
job="kubernetes-apiservers",
le="125000",
- resource="persistentvolumes", s
- cope="cluster",
+ resource="persistentvolumes",
+ scope="cluster",
verb="LIST",
- version=“v1"
+ version="v1"
}
}
```
@@ -118,11 +182,11 @@ use prometheus;
select * from apiserver_request_latencies_bucket;
```
-## Telegraf直接写入
+## Telegraf 直接写入
[Telegraf](https://www.influxdata.com/time-series-platform/telegraf/)是一流行的IT运维数据采集开源工具，TDengine提供一个小工具[Bailongma](https://github.com/taosdata/Bailongma)，只需在Telegraf做简单配置，无需任何代码，就可将Telegraf采集的数据直接写入TDengine，并按规则在TDengine自动创建库和相关表项。博文[用Docker容器快速搭建一个Devops监控Demo](https://www.taosdata.com/blog/2020/02/03/1189.html)即是采用bailongma将Prometheus和Telegraf的数据写入TDengine中的示例，可以参考。
-### 从源代码编译blm_telegraf
+### 从源代码编译 blm_telegraf
用户需要从github下载[Bailongma](https://github.com/taosdata/Bailongma)的源码，使用Golang语言编译器编译生成可执行文件。在开始编译前，需要准备好以下条件：
@@ -139,11 +203,11 @@ go build
一切正常的情况下，就会在对应的目录下生成一个blm_telegraf的可执行程序。
-### 安装Telegraf
+### 安装 Telegraf
目前TDengine支持Telegraf 1.7.4以上的版本。用户可以根据当前的操作系统，到Telegraf官网下载安装包，并执行安装。下载地址如下：https://portal.influxdata.com/downloads 。
-### 配置Telegraf
+### 配置 Telegraf
修改Telegraf配置文件/etc/telegraf/telegraf.conf中与TDengine有关的配置项。
@@ -160,7 +224,8 @@ go build
关于如何使用Telegraf采集数据以及更多有关使用Telegraf的信息，请参考Telegraf官方的[文档](https://docs.influxdata.com/telegraf/v1.11/)。
-### 启动blm_telegraf程序
+### 启动 blm_telegraf 程序
+
blm_telegraf程序有以下选项，在启动blm_telegraf程序时可以通过设定这些选项来设定blm_telegraf的配置。
```bash
@@ -196,7 +261,7 @@ blm_telegraf对telegraf提供服务的端口号。
url = "http://10.1.2.3:8089/telegraf"
```
-### 查询telegraf写入数据
+### 查询 telegraf 写入数据
telegraf产生的数据格式如下：
```json
diff --git a/documentation20/cn/08.connector/docs.md b/documentation20/cn/08.connector/docs.md
index 45395c6f45d140e1185235baeeaef96db4ad36b8..f6a00e64cb3168cef79cb61ad0cb65b5db0c1bef 100644
--- a/documentation20/cn/08.connector/docs.md
+++ b/documentation20/cn/08.connector/docs.md
@@ -64,7 +64,10 @@ TDengine提供了丰富的应用程序开发接口，其中包括C/C++、Java、
编辑taos.cfg文件(默认路径/etc/taos/taos.cfg)，将firstEP修改为TDengine服务器的End Point，例如：h1.taos.com:6030
-**提示： 如本机没有部署TDengine服务，仅安装了应用驱动，则taos.cfg中仅需配置firstEP，无需配置FQDN。**
+**提示： **
+
+1. **如本机没有部署TDengine服务，仅安装了应用驱动，则taos.cfg中仅需配置firstEP，无需配置FQDN。**
+2. **为防止与服务器端连接时出现“unable to resolve FQDN”错误，建议确认客户端的hosts文件已经配置正确的FQDN值。**
**Windows x64/x86**
@@ -96,7 +99,7 @@ TDengine提供了丰富的应用程序开发接口，其中包括C/C++、Java、
**提示：**
1. **如利用FQDN连接服务器，必须确认本机网络环境DNS已配置好，或在hosts文件中添加FQDN寻址记录，如编辑C:\Windows\system32\drivers\etc\hosts，添加如下的记录：`192.168.1.99 h1.taos.com` **
-2．**卸载：运行unins000.exe可卸载TDengine应用驱动。**
+2. **卸载：运行unins000.exe可卸载TDengine应用驱动。**
### 安装验证
@@ -309,7 +312,7 @@ TDengine的异步API均采用非阻塞调用模式。应用程序可以用多线
### 参数绑定 API
-除了直接调用 `taos_query` 进行查询，TDengine 也提供了支持参数绑定的 Prepare API，与 MySQL 一样，这些 API 目前也仅支持用问号 `?` 来代表待绑定的参数。
+除了直接调用 `taos_query` 进行查询，TDengine 也提供了支持参数绑定的 Prepare API，与 MySQL 一样，这些 API 目前也仅支持用问号 `?` 来代表待绑定的参数。文档中有时也会把此功能称为“原生接口写入”。
从 2.1.1.0 和 2.1.2.0 版本开始，TDengine 大幅改进了参数绑定接口对数据写入（INSERT）场景的支持。这样在通过参数绑定接口写入数据时，就避免了 SQL 语法解析的资源消耗，从而在绝大多数情况下显著提升写入性能。此时的典型操作步骤如下：
1. 调用 `taos_stmt_init` 创建参数绑定对象；
@@ -400,6 +403,25 @@ typedef struct TAOS_MULTI_BIND {
（2.1.3.0 版本新增）
用于在其他 stmt API 返回错误（返回错误码或空指针）时获取错误信息。
+
+### Schemaless 方式写入接口
+
+除了使用 SQL 方式或者使用参数绑定 API 写入数据外，还可以使用 Schemaless 的方式完成写入。Schemaless 可以免于预先创建超级表/数据子表的数据结构，而是可以直接写入数据，TDengine 系统会根据写入的数据内容自动创建和维护所需要的表结构。Schemaless 的使用方式详见 [Schemaless 写入](https://www.taosdata.com/cn/documentation/insert#schemaless) 章节，这里介绍与之配套使用的 C/C++ API。
+
+- `int taos_insert_lines(TAOS* taos, char* lines[], int numLines)`
+
+ （2.2.0.0 版本新增）
+ 以 Schemaless 格式写入多行数据。其中：
+ * taos：调用 taos_connect 返回的数据库连接。
+ * lines：由 char 字符串指针组成的数组，指向本次想要写入数据库的多行数据。
+ * numLines：lines 数据的总行数。
+
+ 返回值为 0 表示写入成功，非零值表示出错。具体错误代码请参见 [taoserror.h](https://github.com/taosdata/TDengine/blob/develop/src/inc/taoserror.h) 文件。
+
+ 说明：
+ 1. 此接口是一个同步阻塞式接口，使用时机与 `taos_query()` 一致。
+ 2. 在调用此接口之前，必须先调用 `taos_select_db()` 来确定目前是在向哪个 DB 来写入。
+
### 连续查询接口
TDengine提供时间驱动的实时流式计算API。可以每隔一指定的时间段，对一张或多张数据库的表(数据流)进行各种实时聚合计算操作。操作简单，仅有打开、关闭流的API。具体如下：
diff --git a/documentation20/cn/12.taos-sql/docs.md b/documentation20/cn/12.taos-sql/docs.md
index b96a9c3d285e76384ac8dad64473764bcc76942b..c53972d7ca4178f33e4b359bc0d99059997c70c1 100644
--- a/documentation20/cn/12.taos-sql/docs.md
+++ b/documentation20/cn/12.taos-sql/docs.md
@@ -1258,9 +1258,13 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
适用于：**表、超级表**。
- 说明：（从 2.0.15.0 版本开始新增此函数）INTERP 必须指定时间断面，如果该时间断面不存在直接对应的数据，那么会根据 FILL 参数的设定进行插值。此外，条件语句里面可附带筛选条件，例如标签、tbname。
+ 说明：（从 2.0.15.0 版本开始新增此函数）
- INTERP 查询要求查询的时间区间必须位于数据集合（表）的所有记录的时间范围之内。如果给定的时间戳位于时间范围之外，即使有插值指令，仍然不返回结果。
+ 1）INTERP 必须指定时间断面，如果该时间断面不存在直接对应的数据，那么会根据 FILL 参数的设定进行插值。此外，条件语句里面可附带筛选条件，例如标签、tbname。
+
+ 2）INTERP 查询要求查询的时间区间必须位于数据集合（表）的所有记录的时间范围之内。如果给定的时间戳位于时间范围之外，即使有插值指令，仍然不返回结果。
+
+ 3）单个 INTERP 函数查询只能够针对一个时间点进行查询，如果需要返回等时间间隔的断面数据，可以通过 INTERP 配合 EVERY 的方式来进行查询处理（而不是使用 INTERVAL），其含义是每隔固定长度的时间进行插值。
示例：
```sql
@@ -1284,6 +1288,18 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
Query OK, 1 row(s) in set (0.003056s)
```
+ 如下所示代码表示在时间区间 `['2017-7-14 18:40:00', '2017-7-14 18:40:00.014']` 中每隔 5 毫秒 进行一次断面计算。
+
+ ```sql
+ taos> SELECT INTERP(current) FROM d636 WHERE ts>='2017-7-14 18:40:00' AND ts<='2017-7-14 18:40:00.014' EVERY(5a);
+ ts | interp(current) |
+ =================================================
+ 2017-07-14 18:40:00.000 | 10.04179 |
+ 2017-07-14 18:40:00.010 | 10.16123 |
+ Query OK, 2 row(s) in set (0.003487s)
+
+ ```
+
### 计算函数
- **DIFF**
diff --git a/documentation20/en/08.connector/docs.md b/documentation20/en/08.connector/docs.md
index c111a47450356e81ed1ad1f03192c84b0e471ced..27d38a61f07969df98a6994968c1bc5ccfe2e7dc 100644
--- a/documentation20/en/08.connector/docs.md
+++ b/documentation20/en/08.connector/docs.md
@@ -66,7 +66,11 @@ Run install_client.sh to install.
Edit the taos.cfg file (default path/etc/taos/taos.cfg) and change firstEP to End Point of the TDengine server, for example: [h1.taos.com](http://h1.taos.com/):6030.
-**Tip: If no TDengine service deployed in this machine, but only the application driver is installed, only firstEP needs to be configured in taos.cfg, and FQDN does not.**
+**Tip: **
+
+**1. If no TDengine service deployed in this machine, but only the application driver is installed, only firstEP needs to be configured in taos.cfg, and FQDN does not.**
+
+**2. To prevent “unable to resolve FQDN” error when connecting to the server, ensure that the hosts file of the client has the correct FQDN value.**
**Windows x64/x86**
@@ -128,7 +132,7 @@ taos>
**Windows (x64/x86) environment:**
-Under cmd, enter the c:\ tdengine directory and directly execute taos.exe, and you should be able to connect to tdengine service normally and jump to taos shell interface. For example:
+Under cmd, enter the c:\TDengine directory and directly execute taos.exe, and you should be able to connect to tdengine service normally and jump to taos shell interface. For example:
```mysql
C:\TDengine>taos
diff --git a/documentation20/en/12.taos-sql/docs.md b/documentation20/en/12.taos-sql/docs.md
index 630fbd1cdbeab7d9500b88ab979d708b14441f0a..7aaeb6c32b25cef8f0d1bf2f67ef94c3a2a007ee 100644
--- a/documentation20/en/12.taos-sql/docs.md
+++ b/documentation20/en/12.taos-sql/docs.md
@@ -1,8 +1,8 @@
# TAOS SQL
-TDengine provides a SQL-style language, TAOS SQL, to insert or query data. To read through this document, you should have some basic understanding about SQL.
+TDengine provides a SQL-style language, TAOS SQL, to insert or query data. This document introduces TAOS SQL and supports other common tips. To read through this document, readers should have basic understanding about SQL.
-TAOS SQL is the main way for users to write and query data to TDengine. TAOS SQL is similar to standard SQL to facilitate users to get started quickly. Strictly speaking, TAOS SQL is not and does not attempt to provide SQL standard syntax. In addition, since TDengine does not provide deletion function for time-series data, the relevant function of data deletion is non-existent in TAO SQL.
+TAOS SQL is the main tool for users to write and query data into/from TDengine. TAOS SQL provides a syntax style similar to standard SQL to facilitate users to get started quickly. Strictly speaking, TAOS SQL is not and does not attempt to provide SQL standard syntax. In addition, since TDengine does not provide deletion functionality for time-series data, the relevant functions of data deletion is unsupported in TAO SQL.
Let’s take a look at the conventions used for syntax descriptions.
@@ -37,7 +37,7 @@ With TDengine, the most important thing is timestamp. When creating and insertin
- Epch Time: a timestamp value can also be a long integer representing milliseconds since 1970-01-01 08:00:00.000.
- Arithmetic operations can be applied to timestamp. For example: now-2h represents a timestamp which is 2 hours ago from the current server time. Units include u( microsecond), a (milliseconds), s (seconds), m (minutes), h (hours), d (days), w (weeks). In `select * from t1 where ts > now-2w and ts <= now-1w`, which queries data of the whole week before two weeks. To specify the interval of down sampling, you can also use n(calendar month) and y(calendar year) as time units.
-Default time precision of TDengine is millisecond, you can change it to microseocnd by setting parameter enableMicrosecond.
+TDengine's timestamp is set to millisecond accuracy by default. Microsecond/nanosecond accuracy can be set using CREATE DATABASE with PRECISION parameter. (Nanosecond resolution is supported from version 2.1.5.0 onwards.)
In TDengine, the following 10 data types can be used in data model of an ordinary table.
@@ -1244,4 +1244,4 @@ TAOS SQL supports join columns of two tables by Primary Key timestamp between th
**Availability of is no null**
-Is not null supports all types of columns. Non-null expression is < > "" and only applies to columns of non-numeric types.
\ No newline at end of file
+Is not null supports all types of columns. Non-null expression is < > "" and only applies to columns of non-numeric types.
diff --git a/packaging/tools/install.sh b/packaging/tools/install.sh
index e116d72d2649940f9d272b8d3d01e34576a4049d..9c6a6e62f5b5fda1cfbaf1b5fff9593a5e349271 100755
--- a/packaging/tools/install.sh
+++ b/packaging/tools/install.sh
@@ -102,6 +102,12 @@ elif echo $osinfo | grep -qwi "centos" ; then
elif echo $osinfo | grep -qwi "fedora" ; then
# echo "This is fedora system"
os_type=2
+elif echo $osinfo | grep -qwi "Linx" ; then
+# echo "This is Linx system"
+ os_type=1
+ service_mod=0
+ initd_mod=0
+ service_config_dir="/etc/systemd/system"
else
echo " osinfo: ${osinfo}"
echo " This is an officially unverified linux system,"
diff --git a/src/client/inc/tscParseLine.h b/src/client/inc/tscParseLine.h
new file mode 100644
index 0000000000000000000000000000000000000000..401dcafdfbefd28e79ebdf30d810e194564a5056
--- /dev/null
+++ b/src/client/inc/tscParseLine.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2021 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#ifndef TDENGINE_TSCPARSELINE_H
+#define TDENGINE_TSCPARSELINE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+ char* key;
+ uint8_t type;
+ int16_t length;
+ char* value;
+} TAOS_SML_KV;
+
+typedef struct {
+ char* stableName;
+
+ char* childTableName;
+ TAOS_SML_KV* tags;
+ int32_t tagNum;
+
+ // first kv must be timestamp
+ TAOS_SML_KV* fields;
+ int32_t fieldNum;
+} TAOS_SML_DATA_POINT;
+
+typedef enum {
+ SML_TIME_STAMP_NOW,
+ SML_TIME_STAMP_SECONDS,
+ SML_TIME_STAMP_MILLI_SECONDS,
+ SML_TIME_STAMP_MICRO_SECONDS,
+ SML_TIME_STAMP_NANO_SECONDS
+} SMLTimeStampType;
+
+typedef struct {
+ uint64_t id;
+ SHashObj* smlDataToSchema;
+} SSmlLinesInfo;
+
+int tscSmlInsert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint, SSmlLinesInfo* info);
+bool checkDuplicateKey(char *key, SHashObj *pHash, SSmlLinesInfo* info);
+int32_t isValidChildTableName(const char *pTbName, int16_t len);
+
+bool convertSmlValueType(TAOS_SML_KV *pVal, char *value,
+ uint16_t len, SSmlLinesInfo* info);
+int32_t convertSmlTimeStamp(TAOS_SML_KV *pVal, char *value,
+ uint16_t len, SSmlLinesInfo* info);
+
+void destroySmlDataPoint(TAOS_SML_DATA_POINT* point);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // TDENGINE_TSCPARSELINE_H
diff --git a/src/client/src/tscParseLineProtocol.c b/src/client/src/tscParseLineProtocol.c
index 778c0cfb47ad255663b403412931be71a3200d2a..c9ad7361efa3ade3e3e221a0128a5ad1f3e22ccb 100644
--- a/src/client/src/tscParseLineProtocol.c
+++ b/src/client/src/tscParseLineProtocol.c
@@ -17,6 +17,7 @@
#include "tscLog.h"
#include "taos.h"
+#include "tscParseLine.h"
typedef struct {
char sTableName[TSDB_TABLE_NAME_LEN];
@@ -27,38 +28,6 @@ typedef struct {
uint8_t precision;
} SSmlSTableSchema;
-typedef struct {
- char* key;
- uint8_t type;
- int16_t length;
- char* value;
-} TAOS_SML_KV;
-
-typedef struct {
- char* stableName;
-
- char* childTableName;
- TAOS_SML_KV* tags;
- int32_t tagNum;
-
- // first kv must be timestamp
- TAOS_SML_KV* fields;
- int32_t fieldNum;
-} TAOS_SML_DATA_POINT;
-
-typedef enum {
- SML_TIME_STAMP_NOW,
- SML_TIME_STAMP_SECONDS,
- SML_TIME_STAMP_MILLI_SECONDS,
- SML_TIME_STAMP_MICRO_SECONDS,
- SML_TIME_STAMP_NANO_SECONDS
-} SMLTimeStampType;
-
-typedef struct {
- uint64_t id;
- SHashObj* smlDataToSchema;
-} SSmlLinesInfo;
-
//=================================================================================================
static uint64_t linesSmlHandleId = 0;
@@ -1565,8 +1534,8 @@ static bool convertStrToNumber(TAOS_SML_KV *pVal, char*str, SSmlLinesInfo* info)
return true;
}
//len does not include '\0' from value.
-static bool convertSmlValueType(TAOS_SML_KV *pVal, char *value,
- uint16_t len, SSmlLinesInfo* info) {
+bool convertSmlValueType(TAOS_SML_KV *pVal, char *value,
+ uint16_t len, SSmlLinesInfo* info) {
if (len <= 0) {
return false;
}
@@ -1708,7 +1677,7 @@ static int32_t getTimeStampValue(char *value, uint16_t len,
if (len >= 2) {
for (int i = 0; i < len - 2; ++i) {
if(!isdigit(value[i])) {
- return TSDB_CODE_TSC_LINE_SYNTAX_ERROR;
+ return TSDB_CODE_TSC_INVALID_TIME_STAMP;
}
}
}
@@ -1743,20 +1712,20 @@ static int32_t getTimeStampValue(char *value, uint16_t len,
break;
}
default: {
- return TSDB_CODE_TSC_LINE_SYNTAX_ERROR;
+ return TSDB_CODE_TSC_INVALID_TIME_STAMP;
}
}
return TSDB_CODE_SUCCESS;
}
-static int32_t convertSmlTimeStamp(TAOS_SML_KV *pVal, char *value,
- uint16_t len, SSmlLinesInfo* info) {
+int32_t convertSmlTimeStamp(TAOS_SML_KV *pVal, char *value,
+ uint16_t len, SSmlLinesInfo* info) {
int32_t ret;
SMLTimeStampType type;
int64_t tsVal;
if (!isTimeStamp(value, len, &type)) {
- return TSDB_CODE_TSC_LINE_SYNTAX_ERROR;
+ return TSDB_CODE_TSC_INVALID_TIME_STAMP;
}
ret = getTimeStampValue(value, len, type, &tsVal);
@@ -1805,7 +1774,7 @@ static int32_t parseSmlTimeStamp(TAOS_SML_KV **pTS, const char **index, SSmlLine
return ret;
}
-static bool checkDuplicateKey(char *key, SHashObj *pHash, SSmlLinesInfo* info) {
+bool checkDuplicateKey(char *key, SHashObj *pHash, SSmlLinesInfo* info) {
char *val = NULL;
char *cur = key;
char keyLower[TSDB_COL_NAME_LEN];
@@ -1842,7 +1811,7 @@ static int32_t parseSmlKey(TAOS_SML_KV *pKV, const char **index, SHashObj *pHash
while (*cur != '\0') {
if (len > TSDB_COL_NAME_LEN) {
tscError("SML:0x%"PRIx64" Key field cannot exceeds 65 characters", info->id);
- return TSDB_CODE_TSC_LINE_SYNTAX_ERROR;
+ return TSDB_CODE_TSC_INVALID_COLUMN_LENGTH;
}
//unescaped '=' identifies a tag key
if (*cur == '=' && *(cur - 1) != '\\') {
@@ -1902,7 +1871,7 @@ static bool parseSmlValue(TAOS_SML_KV *pKV, const char **index,
free(pKV->key);
pKV->key = NULL;
free(value);
- return TSDB_CODE_TSC_LINE_SYNTAX_ERROR;
+ return TSDB_CODE_TSC_INVALID_VALUE;
}
free(value);
@@ -1931,7 +1900,7 @@ static int32_t parseSmlMeasurement(TAOS_SML_DATA_POINT *pSml, const char **index
tscError("SML:0x%"PRIx64" Measurement field cannot exceeds 193 characters", info->id);
free(pSml->stableName);
pSml->stableName = NULL;
- return TSDB_CODE_TSC_LINE_SYNTAX_ERROR;
+ return TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
}
//first unescaped comma or space identifies measurement
//if space detected first, meaning no tag in the input
@@ -1958,7 +1927,7 @@ static int32_t parseSmlMeasurement(TAOS_SML_DATA_POINT *pSml, const char **index
}
//Table name can only contain digits(0-9),alphebet(a-z),underscore(_)
-static int32_t isValidChildTableName(const char *pTbName, int16_t len) {
+int32_t isValidChildTableName(const char *pTbName, int16_t len) {
const char *cur = pTbName;
for (int i = 0; i < len; ++i) {
if(!isdigit(cur[i]) && !isalpha(cur[i]) && (cur[i] != '_')) {
@@ -2146,14 +2115,14 @@ int32_t tscParseLines(char* lines[], int numLines, SArray* points, SArray* faile
if (code != TSDB_CODE_SUCCESS) {
tscError("SML:0x%"PRIx64" data point line parse failed. line %d : %s", info->id, i, lines[i]);
destroySmlDataPoint(&point);
- return TSDB_CODE_TSC_LINE_SYNTAX_ERROR;
+ return code;
} else {
tscDebug("SML:0x%"PRIx64" data point line parse success. line %d", info->id, i);
}
taosArrayPush(points, &point);
}
- return 0;
+ return TSDB_CODE_SUCCESS;
}
int taos_insert_lines(TAOS* taos, char* lines[], int numLines) {
diff --git a/src/client/src/tscParseOpenTSDB.c b/src/client/src/tscParseOpenTSDB.c
new file mode 100644
index 0000000000000000000000000000000000000000..397b5d3e97c2ed7fc1a42bd0e773bcff8f659c65
--- /dev/null
+++ b/src/client/src/tscParseOpenTSDB.c
@@ -0,0 +1,424 @@
+#include
+#include
+#include
+#include
+
+#include "hash.h"
+#include "taos.h"
+
+#include "tscUtil.h"
+#include "tsclient.h"
+#include "tscLog.h"
+
+#include "tscParseLine.h"
+
+#define MAX_TELNET_FILEDS_NUM 2
+#define OTS_TIMESTAMP_COLUMN_NAME "ts"
+#define OTS_METRIC_VALUE_COLUMN_NAME "value"
+
+/* telnet style API parser */
+static uint64_t HandleId = 0;
+
+static uint64_t genUID() {
+ uint64_t id;
+
+ do {
+ id = atomic_add_fetch_64(&HandleId, 1);
+ } while (id == 0);
+
+ return id;
+}
+
+static int32_t parseTelnetMetric(TAOS_SML_DATA_POINT *pSml, const char **index, SSmlLinesInfo* info) {
+ const char *cur = *index;
+ uint16_t len = 0;
+
+ pSml->stableName = tcalloc(TSDB_TABLE_NAME_LEN + 1, 1); // +1 to avoid 1772 line over write
+ if (pSml->stableName == NULL){
+ return TSDB_CODE_TSC_OUT_OF_MEMORY;
+ }
+ if (isdigit(*cur)) {
+ tscError("OTD:0x%"PRIx64" Metric cannnot start with digit", info->id);
+ tfree(pSml->stableName);
+ return TSDB_CODE_TSC_LINE_SYNTAX_ERROR;
+ }
+
+ while (*cur != '\0') {
+ if (len > TSDB_TABLE_NAME_LEN) {
+ tscError("OTD:0x%"PRIx64" Metric cannot exceeds 193 characters", info->id);
+ tfree(pSml->stableName);
+ return TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
+ }
+
+ if (*cur == ' ') {
+ break;
+ }
+
+ pSml->stableName[len] = *cur;
+ cur++;
+ len++;
+ }
+ if (len == 0 || *cur == '\0') {
+ tfree(pSml->stableName);
+ return TSDB_CODE_TSC_LINE_SYNTAX_ERROR;
+ }
+
+ pSml->stableName[len] = '\0';
+ *index = cur + 1;
+ tscDebug("OTD:0x%"PRIx64" Stable name in metric:%s|len:%d", info->id, pSml->stableName, len);
+
+ return TSDB_CODE_SUCCESS;
+}
+
+static int32_t parseTelnetTimeStamp(TAOS_SML_KV **pTS, int *num_kvs, const char **index, SSmlLinesInfo* info) {
+ //Timestamp must be the first KV to parse
+ assert(*num_kvs == 0);
+
+ const char *start, *cur;
+ int32_t ret = TSDB_CODE_SUCCESS;
+ int len = 0;
+ char key[] = OTS_TIMESTAMP_COLUMN_NAME;
+ char *value = NULL;
+
+ start = cur = *index;
+ //allocate fields for timestamp and value
+ *pTS = tcalloc(MAX_TELNET_FILEDS_NUM, sizeof(TAOS_SML_KV));
+
+ while(*cur != '\0') {
+ if (*cur == ' ') {
+ break;
+ }
+ cur++;
+ len++;
+ }
+
+ if (len > 0 && *cur != '\0') {
+ value = tcalloc(len + 1, 1);
+ memcpy(value, start, len);
+ } else {
+ tfree(*pTS);
+ return TSDB_CODE_TSC_LINE_SYNTAX_ERROR;
+ }
+
+ ret = convertSmlTimeStamp(*pTS, value, len, info);
+ if (ret) {
+ tfree(value);
+ tfree(*pTS);
+ return ret;
+ }
+ tfree(value);
+
+ (*pTS)->key = tcalloc(sizeof(key), 1);
+ memcpy((*pTS)->key, key, sizeof(key));
+
+ *num_kvs += 1;
+ *index = cur + 1;
+
+ return ret;
+}
+
+static int32_t parseTelnetMetricValue(TAOS_SML_KV **pKVs, int *num_kvs, const char **index, SSmlLinesInfo* info) {
+ //skip timestamp
+ TAOS_SML_KV *pVal = *pKVs + 1;
+ const char *start, *cur;
+ int32_t ret = TSDB_CODE_SUCCESS;
+ int len = 0;
+ char key[] = OTS_METRIC_VALUE_COLUMN_NAME;
+ char *value = NULL;
+
+ start = cur = *index;
+
+ while(*cur != '\0') {
+ if (*cur == ' ') {
+ break;
+ }
+ cur++;
+ len++;
+ }
+
+ if (len > 0 && *cur != '\0') {
+ value = tcalloc(len + 1, 1);
+ memcpy(value, start, len);
+ } else {
+ return TSDB_CODE_TSC_LINE_SYNTAX_ERROR;
+ }
+
+ if (!convertSmlValueType(pVal, value, len, info)) {
+ tscError("OTD:0x%"PRIx64" Failed to convert metric value string(%s) to any type",
+ info->id, value);
+ tfree(value);
+ return TSDB_CODE_TSC_INVALID_VALUE;
+ }
+ tfree(value);
+
+ pVal->key = tcalloc(sizeof(key), 1);
+ memcpy(pVal->key, key, sizeof(key));
+ *num_kvs += 1;
+
+ *index = cur + 1;
+ return ret;
+}
+
+static int32_t parseTelnetTagKey(TAOS_SML_KV *pKV, const char **index, SHashObj *pHash, SSmlLinesInfo* info) {
+ const char *cur = *index;
+ char key[TSDB_COL_NAME_LEN + 1]; // +1 to avoid key[len] over write
+ uint16_t len = 0;
+
+ //key field cannot start with digit
+ if (isdigit(*cur)) {
+ tscError("OTD:0x%"PRIx64" Tag key cannnot start with digit", info->id);
+ return TSDB_CODE_TSC_LINE_SYNTAX_ERROR;
+ }
+ while (*cur != '\0') {
+ if (len > TSDB_COL_NAME_LEN) {
+ tscError("OTD:0x%"PRIx64" Tag key cannot exceeds 65 characters", info->id);
+ return TSDB_CODE_TSC_INVALID_COLUMN_LENGTH;
+ }
+ if (*cur == '=') {
+ break;
+ }
+
+ key[len] = *cur;
+ cur++;
+ len++;
+ }
+ if (len == 0 || *cur == '\0') {
+ return TSDB_CODE_TSC_LINE_SYNTAX_ERROR;
+ }
+ key[len] = '\0';
+
+ if (checkDuplicateKey(key, pHash, info)) {
+ return TSDB_CODE_TSC_DUP_TAG_NAMES;
+ }
+
+ pKV->key = tcalloc(len + 1, 1);
+ memcpy(pKV->key, key, len + 1);
+ //tscDebug("OTD:0x%"PRIx64" Key:%s|len:%d", info->id, pKV->key, len);
+ *index = cur + 1;
+ return TSDB_CODE_SUCCESS;
+}
+
+
+static int32_t parseTelnetTagValue(TAOS_SML_KV *pKV, const char **index,
+ bool *is_last_kv, SSmlLinesInfo* info) {
+ const char *start, *cur;
+ char *value = NULL;
+ uint16_t len = 0;
+ start = cur = *index;
+
+ while (1) {
+ // ',' or '\0' identifies a value
+ if (*cur == ',' || *cur == '\0') {
+ // '\0' indicates end of value
+ *is_last_kv = (*cur == '\0') ? true : false;
+ break;
+ }
+ cur++;
+ len++;
+ }
+
+ if (len == 0) {
+ tfree(pKV->key);
+ return TSDB_CODE_TSC_LINE_SYNTAX_ERROR;
+ }
+
+ value = tcalloc(len + 1, 1);
+ memcpy(value, start, len);
+ value[len] = '\0';
+ if (!convertSmlValueType(pKV, value, len, info)) {
+ tscError("OTD:0x%"PRIx64" Failed to convert sml value string(%s) to any type",
+ info->id, value);
+ //free previous alocated key field
+ tfree(pKV->key);
+ tfree(value);
+ return TSDB_CODE_TSC_INVALID_VALUE;
+ }
+ tfree(value);
+
+ *index = (*cur == '\0') ? cur : cur + 1;
+ return TSDB_CODE_SUCCESS;
+}
+
+static int32_t parseTelnetTagKvs(TAOS_SML_KV **pKVs, int *num_kvs,
+ const char **index, char **childTableName,
+ SHashObj *pHash, SSmlLinesInfo* info) {
+ const char *cur = *index;
+ int32_t ret = TSDB_CODE_SUCCESS;
+ TAOS_SML_KV *pkv;
+ bool is_last_kv = false;
+
+ int32_t capacity = 4;
+ *pKVs = tcalloc(capacity, sizeof(TAOS_SML_KV));
+ pkv = *pKVs;
+
+ while (*cur != '\0') {
+ ret = parseTelnetTagKey(pkv, &cur, pHash, info);
+ if (ret) {
+ tscError("OTD:0x%"PRIx64" Unable to parse key", info->id);
+ return ret;
+ }
+ ret = parseTelnetTagValue(pkv, &cur, &is_last_kv, info);
+ if (ret) {
+ tscError("OTD:0x%"PRIx64" Unable to parse value", info->id);
+ return ret;
+ }
+ if ((strcasecmp(pkv->key, "ID") == 0) && pkv->type == TSDB_DATA_TYPE_BINARY) {
+ ret = isValidChildTableName(pkv->value, pkv->length);
+ if (ret) {
+ return ret;
+ }
+ *childTableName = malloc(pkv->length + 1);
+ memcpy(*childTableName, pkv->value, pkv->length);
+ (*childTableName)[pkv->length] = '\0';
+ tfree(pkv->key);
+ tfree(pkv->value);
+ } else {
+ *num_kvs += 1;
+ }
+
+ if (is_last_kv) {
+ break;
+ }
+
+ //reallocate addtional memory for more kvs
+ if ((*num_kvs + 1) > capacity) {
+ TAOS_SML_KV *more_kvs = NULL;
+ capacity *= 3; capacity /= 2;
+ more_kvs = realloc(*pKVs, capacity * sizeof(TAOS_SML_KV));
+ if (!more_kvs) {
+ return TSDB_CODE_TSC_OUT_OF_MEMORY;
+ }
+ *pKVs = more_kvs;
+ }
+
+ //move pKV points to next TAOS_SML_KV block
+ pkv = *pKVs + *num_kvs;
+ }
+
+ return ret;
+}
+
+int32_t tscParseTelnetLine(const char* line, TAOS_SML_DATA_POINT* smlData, SSmlLinesInfo* info) {
+ const char* index = line;
+ int32_t ret = TSDB_CODE_SUCCESS;
+
+ //Parse metric
+ ret = parseTelnetMetric(smlData, &index, info);
+ if (ret) {
+ tscError("OTD:0x%"PRIx64" Unable to parse metric", info->id);
+ return ret;
+ }
+ tscDebug("OTD:0x%"PRIx64" Parse metric finished", info->id);
+
+ //Parse timestamp
+ ret = parseTelnetTimeStamp(&smlData->fields, &smlData->fieldNum, &index, info);
+ if (ret) {
+ tscError("OTD:0x%"PRIx64" Unable to parse timestamp", info->id);
+ return ret;
+ }
+ tscDebug("OTD:0x%"PRIx64" Parse timestamp finished", info->id);
+
+ //Parse value
+ ret = parseTelnetMetricValue(&smlData->fields, &smlData->fieldNum, &index, info);
+ if (ret) {
+ tscError("OTD:0x%"PRIx64" Unable to parse metric value", info->id);
+ return ret;
+ }
+ tscDebug("OTD:0x%"PRIx64" Parse metric value finished", info->id);
+
+ //Parse tagKVs
+ SHashObj *keyHashTable = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+ ret = parseTelnetTagKvs(&smlData->tags, &smlData->tagNum, &index, &smlData->childTableName, keyHashTable, info);
+ if (ret) {
+ tscError("OTD:0x%"PRIx64" Unable to parse tags", info->id);
+ taosHashCleanup(keyHashTable);
+ return ret;
+ }
+ tscDebug("OTD:0x%"PRIx64" Parse tags finished", info->id);
+ taosHashCleanup(keyHashTable);
+
+
+ return TSDB_CODE_SUCCESS;
+}
+
+int32_t tscParseTelnetLines(char* lines[], int numLines, SArray* points, SArray* failedLines, SSmlLinesInfo* info) {
+ for (int32_t i = 0; i < numLines; ++i) {
+ TAOS_SML_DATA_POINT point = {0};
+ int32_t code = tscParseTelnetLine(lines[i], &point, info);
+ if (code != TSDB_CODE_SUCCESS) {
+ tscError("OTD:0x%"PRIx64" data point line parse failed. line %d : %s", info->id, i, lines[i]);
+ destroySmlDataPoint(&point);
+ return code;
+ } else {
+ tscDebug("OTD:0x%"PRIx64" data point line parse success. line %d", info->id, i);
+ }
+
+ taosArrayPush(points, &point);
+ }
+ return TSDB_CODE_SUCCESS;
+}
+
+int taos_insert_telnet_lines(TAOS* taos, char* lines[], int numLines) {
+ int32_t code = 0;
+
+ SSmlLinesInfo* info = tcalloc(1, sizeof(SSmlLinesInfo));
+ info->id = genUID();
+
+ if (numLines <= 0 || numLines > 65536) {
+ tscError("OTD:0x%"PRIx64" taos_insert_telnet_lines numLines should be between 1 and 65536. numLines: %d", info->id, numLines);
+ tfree(info);
+ code = TSDB_CODE_TSC_APP_ERROR;
+ return code;
+ }
+
+ for (int i = 0; i < numLines; ++i) {
+ if (lines[i] == NULL) {
+ tscError("OTD:0x%"PRIx64" taos_insert_telnet_lines line %d is NULL", info->id, i);
+ tfree(info);
+ code = TSDB_CODE_TSC_APP_ERROR;
+ return code;
+ }
+ }
+
+ SArray* lpPoints = taosArrayInit(numLines, sizeof(TAOS_SML_DATA_POINT));
+ if (lpPoints == NULL) {
+ tscError("OTD:0x%"PRIx64" taos_insert_telnet_lines failed to allocate memory", info->id);
+ tfree(info);
+ return TSDB_CODE_TSC_OUT_OF_MEMORY;
+ }
+
+ tscDebug("OTD:0x%"PRIx64" taos_insert_telnet_lines begin inserting %d lines, first line: %s", info->id, numLines, lines[0]);
+ code = tscParseTelnetLines(lines, numLines, lpPoints, NULL, info);
+ size_t numPoints = taosArrayGetSize(lpPoints);
+
+ if (code != 0) {
+ goto cleanup;
+ }
+
+ TAOS_SML_DATA_POINT* points = TARRAY_GET_START(lpPoints);
+ code = tscSmlInsert(taos, points, (int)numPoints, info);
+ if (code != 0) {
+ tscError("OTD:0x%"PRIx64" taos_insert_telnet_lines error: %s", info->id, tstrerror((code)));
+ }
+
+cleanup:
+ tscDebug("OTD:0x%"PRIx64" taos_insert_telnet_lines finish inserting %d lines. code: %d", info->id, numLines, code);
+ points = TARRAY_GET_START(lpPoints);
+ numPoints = taosArrayGetSize(lpPoints);
+ for (int i=0; iid = genUID();
+ int code = tscSmlInsert(taos, points, numPoint, info);
+ tfree(info);
+ return code;
+}
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index c583e566b917043050783d83bc901c7cdaba9d27..b87ec92ff1f056fdc5eeb8992cec418d07158b0b 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -1067,6 +1067,8 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
pMsg += pCond->len;
}
+ } else {
+ pQueryMsg->tagCondLen = 0;
}
if (pQueryInfo->bufLen > 0) {
@@ -1138,6 +1140,7 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
}
} else {
pQueryMsg->udfContentOffset = 0;
+ pQueryMsg->udfContentLen = 0;
}
memcpy(pMsg, pSql->sqlstr, sqlLen);
@@ -2631,7 +2634,11 @@ int tscProcessAlterTableMsgRsp(SSqlObj *pSql) {
tfree(pTableMetaInfo->pTableMeta);
if (isSuperTable) { // if it is a super table, iterate the hashTable and remove all the childTableMeta
- taosHashClear(tscTableMetaMap);
+ if (pSql->res.pRsp == NULL) {
+ tscDebug("0x%"PRIx64" unexpected resp from mnode, super table: %s failed to update super table meta ", pSql->self, name);
+ return 0;
+ }
+ return tscProcessTableMetaRsp(pSql);
}
return 0;
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index 6a75ff5f091f789aa50369e4f1c30647013a5933..2bd601d812294ea311e30fece732d1e1c2c533ec 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -2085,7 +2085,7 @@ int32_t tscAllocPayloadFast(SSqlCmd *pCmd, size_t size) {
assert(pCmd->allocSize == 0);
pCmd->payload = malloc(size);
- pCmd->allocSize = size;
+ pCmd->allocSize = (uint32_t) size;
} else if (pCmd->allocSize < size) {
char* tmp = realloc(pCmd->payload, size);
if (tmp == NULL) {
@@ -2093,7 +2093,7 @@ int32_t tscAllocPayloadFast(SSqlCmd *pCmd, size_t size) {
}
pCmd->payload = tmp;
- pCmd->allocSize = size;
+ pCmd->allocSize = (uint32_t) size;
}
assert(pCmd->allocSize >= size);
diff --git a/src/common/inc/tglobal.h b/src/common/inc/tglobal.h
index 4fc4e41608794b8eacb395d96496e31588df39c7..b60c7e38dcecba45b9e3228897cbaa05ef7a5bd1 100644
--- a/src/common/inc/tglobal.h
+++ b/src/common/inc/tglobal.h
@@ -229,6 +229,8 @@ extern uint32_t maxRange;
extern uint32_t curRange;
extern char Compressor[];
#endif
+// long query
+extern int8_t tsDeadLockKillQuery;
typedef struct {
char dir[TSDB_FILENAME_LEN];
diff --git a/src/common/src/tglobal.c b/src/common/src/tglobal.c
index 8d4b18835408b218ee6d929bac610083e7bf1f10..fa9162b9e0ae3f9b92113f773eb6b49cfed8e2aa 100644
--- a/src/common/src/tglobal.c
+++ b/src/common/src/tglobal.c
@@ -284,6 +284,9 @@ uint32_t curRange = 100; // range
char Compressor[32] = "ZSTD_COMPRESSOR"; // ZSTD_COMPRESSOR or GZIP_COMPRESSOR
#endif
+// long query death-lock
+int8_t tsDeadLockKillQuery = 0;
+
int32_t (*monStartSystemFp)() = NULL;
void (*monStopSystemFp)() = NULL;
void (*monExecuteSQLFp)(char *sql) = NULL;
@@ -1618,7 +1621,17 @@ static void doInitGlobalConfig(void) {
cfg.unitType = TAOS_CFG_UTYPE_NONE;
taosInitConfigOption(cfg);
- assert(tsGlobalConfigNum <= TSDB_CFG_MAX_NUM);
+ // enable kill long query
+ cfg.option = "deadLockKillQuery";
+ cfg.ptr = &tsDeadLockKillQuery;
+ cfg.valType = TAOS_CFG_VTYPE_INT8;
+ cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_SHOW;
+ cfg.minValue = 0;
+ cfg.maxValue = 1;
+ cfg.ptrLength = 1;
+ cfg.unitType = TAOS_CFG_UTYPE_NONE;
+ taosInitConfigOption(cfg);
+
#ifdef TD_TSZ
// lossy compress
cfg.option = "lossyColumns";
@@ -1672,6 +1685,9 @@ static void doInitGlobalConfig(void) {
cfg.ptrLength = 0;
cfg.unitType = TAOS_CFG_UTYPE_NONE;
taosInitConfigOption(cfg);
+ assert(tsGlobalConfigNum == TSDB_CFG_MAX_NUM);
+#else
+ assert(tsGlobalConfigNum == TSDB_CFG_MAX_NUM - 5);
#endif
}
diff --git a/src/connector/python/taos/cinterface.py b/src/connector/python/taos/cinterface.py
index a1b6fe312b5725b8bf030701608d93c3e0c85706..aad9d1fdbfd4f900fe2db96dadbf343ea922be22 100644
--- a/src/connector/python/taos/cinterface.py
+++ b/src/connector/python/taos/cinterface.py
@@ -827,6 +827,16 @@ def taos_insert_lines(connection, lines):
if errno != 0:
raise LinesError("insert lines error", errno)
+def taos_insert_telnet_lines(connection, lines):
+ # type: (c_void_p, list[str] | tuple(str)) -> None
+ num_of_lines = len(lines)
+ lines = (c_char_p(line.encode("utf-8")) for line in lines)
+ lines_type = ctypes.c_char_p * num_of_lines
+ p_lines = lines_type(*lines)
+ errno = _libtaos.taos_insert_telnet_lines(connection, p_lines, num_of_lines)
+ if errno != 0:
+ raise LinesError("insert telnet lines error", errno)
+
class CTaosInterface(object):
def __init__(self, config=None):
diff --git a/src/connector/python/taos/connection.py b/src/connector/python/taos/connection.py
index 7857c8c706dbe27fd9440e6bf2eb698b6822650e..a8a71ecc3a8a5f2bdc960df364213e80018a70fe 100644
--- a/src/connector/python/taos/connection.py
+++ b/src/connector/python/taos/connection.py
@@ -145,6 +145,15 @@ class TaosConnection(object):
"""
return taos_insert_lines(self._conn, lines)
+ def insert_telnet_lines(self, lines):
+ """OpenTSDB telnet style API format support
+
+ ## Example
+ cpu_load 1626056811855516532ns 2.0f32 id="tb1",host="host0",interface="eth0"
+
+ """
+ return taos_insert_telnet_lines(self._conn, lines)
+
def cursor(self):
# type: () -> TaosCursor
"""Return a new Cursor object using the connection."""
diff --git a/src/inc/query.h b/src/inc/query.h
index fb9cbff8584892b4a6bc6e4a6ce046a7500aef39..0872e3dbaa517ded77dd758b30e69f273c13a580 100644
--- a/src/inc/query.h
+++ b/src/inc/query.h
@@ -76,6 +76,11 @@ void* qGetResultRetrieveMsg(qinfo_t qinfo);
*/
int32_t qKillQuery(qinfo_t qinfo);
+//kill by qid
+int32_t qKillQueryByQId(void* pMgmt, int64_t qId, int32_t waitMs, int32_t waitCount);
+
+bool qSolveCommitNoBlock(void* pRepo, void* pMgmt);
+
int32_t qQueryCompleted(qinfo_t qinfo);
/**
diff --git a/src/inc/taos.h b/src/inc/taos.h
index 6fa30737e71e8f40cee817386ad4d2c26661777f..a71e4bf50c600a8c9963e616c5e79cbfbe164556 100644
--- a/src/inc/taos.h
+++ b/src/inc/taos.h
@@ -172,6 +172,8 @@ DLL_EXPORT int taos_load_table_info(TAOS *taos, const char* tableNameList);
DLL_EXPORT int taos_insert_lines(TAOS* taos, char* lines[], int numLines);
+DLL_EXPORT int taos_insert_telnet_lines(TAOS* taos, char* lines[], int numLines);
+
#ifdef __cplusplus
}
#endif
diff --git a/src/inc/taoserror.h b/src/inc/taoserror.h
index c401ab762eb7f17b075ca52ab1e9454eb136a2ab..5b4657f7a322bb351e4d41711d2960f4ac2b7657 100644
--- a/src/inc/taoserror.h
+++ b/src/inc/taoserror.h
@@ -35,6 +35,7 @@ int32_t* taosGetErrno();
#define terrno (*taosGetErrno())
#define TSDB_CODE_SUCCESS 0
+#define TSDB_CODE_FAILED -1 // unknown or needn't tell detail error
// rpc
#define TSDB_CODE_RPC_ACTION_IN_PROGRESS TAOS_DEF_ERROR_CODE(0, 0x0001) //"Action in progress")
@@ -106,6 +107,7 @@ int32_t* taosGetErrno();
#define TSDB_CODE_TSC_DUP_COL_NAMES TAOS_DEF_ERROR_CODE(0, 0x021D) //"duplicated column names")
#define TSDB_CODE_TSC_INVALID_TAG_LENGTH TAOS_DEF_ERROR_CODE(0, 0x021E) //"Invalid tag length")
#define TSDB_CODE_TSC_INVALID_COLUMN_LENGTH TAOS_DEF_ERROR_CODE(0, 0x021F) //"Invalid column length")
+#define TSDB_CODE_TSC_DUP_TAG_NAMES TAOS_DEF_ERROR_CODE(0, 0x0220) //"duplicated tag names")
// mnode
#define TSDB_CODE_MND_MSG_NOT_PROCESSED TAOS_DEF_ERROR_CODE(0, 0x0300) //"Message not processed")
diff --git a/src/inc/tsdb.h b/src/inc/tsdb.h
index 7abe3e99c720af1682fc103beec9a5d4caeb09eb..089e30ac3728761c68fe155f960c8650a32c2f7a 100644
--- a/src/inc/tsdb.h
+++ b/src/inc/tsdb.h
@@ -39,6 +39,7 @@ extern "C" {
#define TSDB_STATUS_COMMIT_START 1
#define TSDB_STATUS_COMMIT_OVER 2
+#define TSDB_STATUS_COMMIT_NOBLOCK 3 //commit no block, need to be solved
// TSDB STATE DEFINITION
#define TSDB_STATE_OK 0x0
@@ -413,6 +414,11 @@ int tsdbSyncRecv(void *pRepo, SOCKET socketFd);
// For TSDB Compact
int tsdbCompact(STsdbRepo *pRepo);
+// For TSDB Health Monitor
+
+// no problem return true
+bool tsdbNoProblem(STsdbRepo* pRepo);
+
#ifdef __cplusplus
}
#endif
diff --git a/src/kit/shell/src/shellDarwin.c b/src/kit/shell/src/shellDarwin.c
index 9161860f07dfb0683a47ea4ccb2a759ae49562e7..a1413be1ce4ce6f67516fc09121115f30bbc56f0 100644
--- a/src/kit/shell/src/shellDarwin.c
+++ b/src/kit/shell/src/shellDarwin.c
@@ -98,6 +98,7 @@ void shellParseArgument(int argc, char *argv[], SShellArguments *arguments) {
tstrncpy(g_password, (char *)(argv[i] + 2), SHELL_MAX_PASSWORD_LEN);
}
arguments->password = g_password;
+ arguments->is_use_passwd = true;
strcpy(argv[i], "");
argc -= 1;
}
diff --git a/src/kit/taosdemo/taosdemo.c b/src/kit/taosdemo/taosdemo.c
index 6432ce42b7eccc744c880ea3fc9c7fd05d2c36f6..c9d284828b7e4ab37b1f197c0a0bf869175146af 100644
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
@@ -20,6 +20,7 @@
#include
#include
+#include
#define _GNU_SOURCE
#define CURL_STATICLIB
@@ -87,7 +88,7 @@ extern char configDir[];
#define DOUBLE_BUFF_LEN 42
#define TIMESTAMP_BUFF_LEN 21
-#define MAX_SAMPLES_ONCE_FROM_FILE 10000
+#define MAX_SAMPLES 10000
#define MAX_NUM_COLUMNS (TSDB_MAX_COLUMNS - 1) // exclude first column timestamp
#define MAX_DB_COUNT 8
@@ -109,6 +110,14 @@ extern char configDir[];
#define DEFAULT_CHILDTABLES 10000
+#define STMT_BIND_PARAM_BATCH 0
+
+char* g_sampleDataBuf = NULL;
+#if STMT_BIND_PARAM_BATCH == 1
+ // bind param batch
+char* g_sampleBindBatchArray = NULL;
+#endif
+
enum TEST_MODE {
INSERT_TEST, // 0
QUERY_TEST, // 1
@@ -116,17 +125,17 @@ enum TEST_MODE {
INVAID_TEST
};
-typedef enum CREATE_SUB_TALBE_MOD_EN {
+typedef enum CREATE_SUB_TABLE_MOD_EN {
PRE_CREATE_SUBTBL,
AUTO_CREATE_SUBTBL,
NO_CREATE_SUBTBL
-} CREATE_SUB_TALBE_MOD_EN;
+} CREATE_SUB_TABLE_MOD_EN;
-typedef enum TALBE_EXISTS_EN {
+typedef enum TABLE_EXISTS_EN {
TBL_NO_EXISTS,
TBL_ALREADY_EXISTS,
TBL_EXISTS_BUTT
-} TALBE_EXISTS_EN;
+} TABLE_EXISTS_EN;
enum enumSYNC_MODE {
SYNC_MODE,
@@ -226,21 +235,23 @@ typedef struct SArguments_S {
bool performance_print;
char * output_file;
bool async_mode;
- char * datatype[MAX_NUM_COLUMNS + 1];
+ char data_type[MAX_NUM_COLUMNS+1];
+ char *dataType[MAX_NUM_COLUMNS+1];
uint32_t binwidth;
- uint32_t num_of_CPR;
- uint32_t num_of_threads;
+ uint32_t columnCount;
+ uint64_t lenOfOneRow;
+ uint32_t nthreads;
uint64_t insert_interval;
uint64_t timestamp_step;
int64_t query_times;
- uint32_t interlace_rows;
- uint32_t num_of_RPR; // num_of_records_per_req
+ uint32_t interlaceRows;
+ uint32_t reqPerReq; // num_of_records_per_req
uint64_t max_sql_len;
- int64_t num_of_tables;
- int64_t num_of_DPT;
+ int64_t ntables;
+ int64_t insertRows;
int abort;
uint32_t disorderRatio; // 0: no disorder, >0: x%
- int disorderRange; // ms, us or ns. accordig to database precision
+ int disorderRange; // ms, us or ns. according to database precision
uint32_t method_of_delete;
uint64_t totalInsertRows;
uint64_t totalAffectedRows;
@@ -248,14 +259,15 @@ typedef struct SArguments_S {
} SArguments;
typedef struct SColumn_S {
- char field[TSDB_COL_NAME_LEN];
- char dataType[DATATYPE_BUFF_LEN];
- uint32_t dataLen;
- char note[NOTE_BUFF_LEN];
+ char field[TSDB_COL_NAME_LEN];
+ char data_type;
+ char dataType[DATATYPE_BUFF_LEN];
+ uint32_t dataLen;
+ char note[NOTE_BUFF_LEN];
} StrColumn;
typedef struct SSuperTable_S {
- char sTblName[TSDB_TABLE_NAME_LEN];
+ char stbName[TSDB_TABLE_NAME_LEN];
char dataSource[SMALL_BUFF_LEN]; // rand_gen or sample
char childTblPrefix[TBNAME_PREFIX_LEN];
uint16_t childTblExists;
@@ -291,14 +303,16 @@ typedef struct SSuperTable_S {
uint64_t lenOfTagOfOneRow;
char* sampleDataBuf;
- //int sampleRowCount;
- //int sampleUsePos;
uint32_t tagSource; // 0: rand, 1: tag sample
char* tagDataBuf;
uint32_t tagSampleCount;
uint32_t tagUsePos;
+#if STMT_BIND_PARAM_BATCH == 1
+ // bind param batch
+ char *sampleBindBatchArray;
+#endif
// statistics
uint64_t totalInsertRows;
uint64_t totalAffectedRows;
@@ -378,7 +392,7 @@ typedef struct SDbs_S {
} SDbs;
typedef struct SpecifiedQueryInfo_S {
- uint64_t queryInterval; // 0: unlimit > 0 loop/s
+ uint64_t queryInterval; // 0: unlimited > 0 loop/s
uint32_t concurrent;
int sqlCount;
uint32_t asyncMode; // 0: sync, 1: async
@@ -398,8 +412,8 @@ typedef struct SpecifiedQueryInfo_S {
} SpecifiedQueryInfo;
typedef struct SuperQueryInfo_S {
- char sTblName[TSDB_TABLE_NAME_LEN];
- uint64_t queryInterval; // 0: unlimit > 0 loop/s
+ char stbName[TSDB_TABLE_NAME_LEN];
+ uint64_t queryInterval; // 0: unlimited > 0 loop/s
uint32_t threadCnt;
uint32_t asyncMode; // 0: sync, 1: async
uint64_t subscribeInterval; // ms
@@ -437,8 +451,16 @@ typedef struct SQueryMetaInfo_S {
typedef struct SThreadInfo_S {
TAOS * taos;
TAOS_STMT *stmt;
- char* sampleBindArray;
- int64_t *bind_ts;
+ int64_t *bind_ts;
+
+#if STMT_BIND_PARAM_BATCH == 1
+ int64_t *bind_ts_array;
+ char *bindParams;
+ char *is_null;
+#else
+ char* sampleBindArray;
+#endif
+
int threadID;
char db_name[TSDB_DB_NAME_LEN];
uint32_t time_precision;
@@ -584,8 +606,8 @@ char *g_rand_current_buff = NULL;
char *g_rand_phase_buff = NULL;
char *g_randdouble_buff = NULL;
-char *g_aggreFunc[] = {"*", "count(*)", "avg(col0)", "sum(col0)",
- "max(col0)", "min(col0)", "first(col0)", "last(col0)"};
+char *g_aggreFunc[] = {"*", "count(*)", "avg(C0)", "sum(C0)",
+ "max(C0)", "min(C0)", "first(C0)", "last(C0)"};
SArguments g_args = {
NULL, // metaFile
@@ -614,22 +636,26 @@ SArguments g_args = {
false, // answer_yes;
"./output.txt", // output_file
0, // mode : sync or async
+ {TSDB_DATA_TYPE_FLOAT,
+ TSDB_DATA_TYPE_INT,
+ TSDB_DATA_TYPE_FLOAT},
{
- "FLOAT", // datatype
- "INT", // datatype
- "FLOAT", // datatype. DEFAULT_DATATYPE_NUM is 3
+ "FLOAT", // dataType
+ "INT", // dataType
+ "FLOAT", // dataType. demo mode has 3 columns
},
64, // binwidth
- 4, // num_of_CPR
- 10, // num_of_connections/thread
+ 4, // columnCount, timestamp + float + int + float
+ 20 + FLOAT_BUFF_LEN + INT_BUFF_LEN + FLOAT_BUFF_LEN, // lenOfOneRow
+ 8, // num_of_connections/thread
0, // insert_interval
DEFAULT_TIMESTAMP_STEP, // timestamp_step
1, // query_times
- DEFAULT_INTERLACE_ROWS, // interlace_rows;
- 30000, // num_of_RPR
+ DEFAULT_INTERLACE_ROWS, // interlaceRows;
+ 30000, // reqPerReq
(1024*1024), // max_sql_len
- DEFAULT_CHILDTABLES, // num_of_tables
- 10000, // num_of_DPT
+ DEFAULT_CHILDTABLES, // ntables
+ 10000, // insertRows
0, // abort
0, // disorderRatio
1000, // disorderRange
@@ -711,10 +737,10 @@ static void printVersion() {
char taosdemo_status[] = TAOSDEMO_STATUS;
if (strlen(taosdemo_status) == 0) {
- printf("taosdemo verison %s-%s\n",
+ printf("taosdemo version %s-%s\n",
tdengine_ver, taosdemo_ver);
} else {
- printf("taosdemo verison %s-%s, status:%s\n",
+ printf("taosdemo version %s-%s, status:%s\n",
tdengine_ver, taosdemo_ver, taosdemo_status);
}
}
@@ -791,7 +817,7 @@ static void printHelp() {
"The number of records per table. Default is 10000.");
printf("%s%s%s%s\n", indent, "-M, --random", "\t\t\t",
"The value of records generated are totally random.");
- printf("%s\n", "\t\t\t\tThe default is to simulate power equipment senario.");
+ printf("%s\n", "\t\t\t\tThe default is to simulate power equipment scenario.");
printf("%s%s%s%s\n", indent, "-x, --no-insert", "\t\t",
"No-insert flag.");
printf("%s%s%s%s\n", indent, "-y, --answer-yes", "\t\t", "Default input yes for prompt.");
@@ -836,7 +862,7 @@ static void errorWrongValue(char *program, char *wrong_arg, char *wrong_value)
fprintf(stderr, "Try `taosdemo --help' or `taosdemo --usage' for more information.\n");
}
-static void errorUnreconized(char *program, char *wrong_arg)
+static void errorUnrecognized(char *program, char *wrong_arg)
{
fprintf(stderr, "%s: unrecognized options '%s'\n", program, wrong_arg);
fprintf(stderr, "Try `taosdemo --help' or `taosdemo --usage' for more information.\n");
@@ -893,7 +919,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
} else if (0 == strncmp(argv[i], "--file=", strlen("--file="))) {
arguments->metaFile = (char *)(argv[i] + strlen("--file="));
} else {
- errorUnreconized(argv[0], argv[i]);
+ errorUnrecognized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
} else if ((0 == strncmp(argv[i], "-c", strlen("-c")))
@@ -915,7 +941,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
} else if (0 == strncmp(argv[i], "--config-dir=", strlen("--config-dir="))) {
tstrncpy(configDir, (char *)(argv[i] + strlen("--config-dir=")), TSDB_FILENAME_LEN);
} else {
- errorUnreconized(argv[0], argv[i]);
+ errorUnrecognized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
} else if ((0 == strncmp(argv[i], "-h", strlen("-h")))
@@ -937,7 +963,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
} else if (0 == strncmp(argv[i], "--host=", strlen("--host="))) {
arguments->host = (char *)(argv[i] + strlen("--host="));
} else {
- errorUnreconized(argv[0], argv[i]);
+ errorUnrecognized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
} else if (strcmp(argv[i], "-PP") == 0) {
@@ -971,7 +997,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
}
arguments->port = atoi(argv[++i]);
} else {
- errorUnreconized(argv[0], argv[i]);
+ errorUnrecognized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
} else if ((0 == strncmp(argv[i], "-I", strlen("-I")))
@@ -1032,7 +1058,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
}
i++;
} else {
- errorUnreconized(argv[0], argv[i]);
+ errorUnrecognized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
} else if ((0 == strncmp(argv[i], "-u", strlen("-u")))
@@ -1054,7 +1080,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
}
arguments->user = argv[++i];
} else {
- errorUnreconized(argv[0], argv[i]);
+ errorUnrecognized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
} else if ((0 == strncmp(argv[i], "-p", strlen("-p")))
@@ -1088,7 +1114,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
}
arguments->output_file = argv[++i];
} else {
- errorUnreconized(argv[0], argv[i]);
+ errorUnrecognized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
} else if ((0 == strncmp(argv[i], "-s", strlen("-s")))
@@ -1110,7 +1136,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
}
arguments->sqlFile = argv[++i];
} else {
- errorUnreconized(argv[0], argv[i]);
+ errorUnrecognized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
} else if ((0 == strncmp(argv[i], "-q", strlen("-q")))
@@ -1148,7 +1174,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
}
arguments->async_mode = atoi(argv[++i]);
} else {
- errorUnreconized(argv[0], argv[i]);
+ errorUnrecognized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
} else if ((0 == strncmp(argv[i], "-T", strlen("-T")))
@@ -1161,17 +1187,17 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
errorPrintReqArg2(argv[0], "T");
exit(EXIT_FAILURE);
}
- arguments->num_of_threads = atoi(argv[++i]);
+ arguments->nthreads = atoi(argv[++i]);
} else if (0 == strncmp(argv[i], "--threads=", strlen("--threads="))) {
if (isStringNumber((char *)(argv[i] + strlen("--threads=")))) {
- arguments->num_of_threads = atoi((char *)(argv[i]+strlen("--threads=")));
+ arguments->nthreads = atoi((char *)(argv[i]+strlen("--threads=")));
} else {
errorPrintReqArg2(argv[0], "--threads");
exit(EXIT_FAILURE);
}
} else if (0 == strncmp(argv[i], "-T", strlen("-T"))) {
if (isStringNumber((char *)(argv[i] + strlen("-T")))) {
- arguments->num_of_threads = atoi((char *)(argv[i]+strlen("-T")));
+ arguments->nthreads = atoi((char *)(argv[i]+strlen("-T")));
} else {
errorPrintReqArg2(argv[0], "-T");
exit(EXIT_FAILURE);
@@ -1184,9 +1210,9 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
errorPrintReqArg2(argv[0], "--threads");
exit(EXIT_FAILURE);
}
- arguments->num_of_threads = atoi(argv[++i]);
+ arguments->nthreads = atoi(argv[++i]);
} else {
- errorUnreconized(argv[0], argv[i]);
+ errorUnrecognized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
} else if ((0 == strncmp(argv[i], "-i", strlen("-i")))
@@ -1224,7 +1250,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
}
arguments->insert_interval = atoi(argv[++i]);
} else {
- errorUnreconized(argv[0], argv[i]);
+ errorUnrecognized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
} else if ((0 == strncmp(argv[i], "-S", strlen("-S")))
@@ -1262,7 +1288,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
}
arguments->async_mode = atoi(argv[++i]);
} else {
- errorUnreconized(argv[0], argv[i]);
+ errorUnrecognized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
} else if (strcmp(argv[i], "-qt") == 0) {
@@ -1283,17 +1309,17 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
errorPrintReqArg2(argv[0], "B");
exit(EXIT_FAILURE);
}
- arguments->interlace_rows = atoi(argv[++i]);
+ arguments->interlaceRows = atoi(argv[++i]);
} else if (0 == strncmp(argv[i], "--interlace-rows=", strlen("--interlace-rows="))) {
if (isStringNumber((char *)(argv[i] + strlen("--interlace-rows=")))) {
- arguments->interlace_rows = atoi((char *)(argv[i]+strlen("--interlace-rows=")));
+ arguments->interlaceRows = atoi((char *)(argv[i]+strlen("--interlace-rows=")));
} else {
errorPrintReqArg2(argv[0], "--interlace-rows");
exit(EXIT_FAILURE);
}
} else if (0 == strncmp(argv[i], "-B", strlen("-B"))) {
if (isStringNumber((char *)(argv[i] + strlen("-B")))) {
- arguments->interlace_rows = atoi((char *)(argv[i]+strlen("-B")));
+ arguments->interlaceRows = atoi((char *)(argv[i]+strlen("-B")));
} else {
errorPrintReqArg2(argv[0], "-B");
exit(EXIT_FAILURE);
@@ -1306,9 +1332,9 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
errorPrintReqArg2(argv[0], "--interlace-rows");
exit(EXIT_FAILURE);
}
- arguments->interlace_rows = atoi(argv[++i]);
+ arguments->interlaceRows = atoi(argv[++i]);
} else {
- errorUnreconized(argv[0], argv[i]);
+ errorUnrecognized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
} else if ((0 == strncmp(argv[i], "-r", strlen("-r")))
@@ -1321,17 +1347,17 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
errorPrintReqArg2(argv[0], "r");
exit(EXIT_FAILURE);
}
- arguments->num_of_RPR = atoi(argv[++i]);
+ arguments->reqPerReq = atoi(argv[++i]);
} else if (0 == strncmp(argv[i], "--rec-per-req=", strlen("--rec-per-req="))) {
if (isStringNumber((char *)(argv[i] + strlen("--rec-per-req=")))) {
- arguments->num_of_RPR = atoi((char *)(argv[i]+strlen("--rec-per-req=")));
+ arguments->reqPerReq = atoi((char *)(argv[i]+strlen("--rec-per-req=")));
} else {
errorPrintReqArg2(argv[0], "--rec-per-req");
exit(EXIT_FAILURE);
}
} else if (0 == strncmp(argv[i], "-r", strlen("-r"))) {
if (isStringNumber((char *)(argv[i] + strlen("-r")))) {
- arguments->num_of_RPR = atoi((char *)(argv[i]+strlen("-r")));
+ arguments->reqPerReq = atoi((char *)(argv[i]+strlen("-r")));
} else {
errorPrintReqArg2(argv[0], "-r");
exit(EXIT_FAILURE);
@@ -1344,9 +1370,9 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
errorPrintReqArg2(argv[0], "--rec-per-req");
exit(EXIT_FAILURE);
}
- arguments->num_of_RPR = atoi(argv[++i]);
+ arguments->reqPerReq = atoi(argv[++i]);
} else {
- errorUnreconized(argv[0], argv[i]);
+ errorUnrecognized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
} else if ((0 == strncmp(argv[i], "-t", strlen("-t")))
@@ -1359,17 +1385,17 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
errorPrintReqArg2(argv[0], "t");
exit(EXIT_FAILURE);
}
- arguments->num_of_tables = atoi(argv[++i]);
+ arguments->ntables = atoi(argv[++i]);
} else if (0 == strncmp(argv[i], "--tables=", strlen("--tables="))) {
if (isStringNumber((char *)(argv[i] + strlen("--tables=")))) {
- arguments->num_of_tables = atoi((char *)(argv[i]+strlen("--tables=")));
+ arguments->ntables = atoi((char *)(argv[i]+strlen("--tables=")));
} else {
errorPrintReqArg2(argv[0], "--tables");
exit(EXIT_FAILURE);
}
} else if (0 == strncmp(argv[i], "-t", strlen("-t"))) {
if (isStringNumber((char *)(argv[i] + strlen("-t")))) {
- arguments->num_of_tables = atoi((char *)(argv[i]+strlen("-t")));
+ arguments->ntables = atoi((char *)(argv[i]+strlen("-t")));
} else {
errorPrintReqArg2(argv[0], "-t");
exit(EXIT_FAILURE);
@@ -1382,13 +1408,13 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
errorPrintReqArg2(argv[0], "--tables");
exit(EXIT_FAILURE);
}
- arguments->num_of_tables = atoi(argv[++i]);
+ arguments->ntables = atoi(argv[++i]);
} else {
- errorUnreconized(argv[0], argv[i]);
+ errorUnrecognized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
- g_totalChildTables = arguments->num_of_tables;
+ g_totalChildTables = arguments->ntables;
} else if ((0 == strncmp(argv[i], "-n", strlen("-n")))
|| (0 == strncmp(argv[i], "--records", strlen("--records")))) {
if (2 == strlen(argv[i])) {
@@ -1399,17 +1425,17 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
errorPrintReqArg2(argv[0], "n");
exit(EXIT_FAILURE);
}
- arguments->num_of_DPT = atoi(argv[++i]);
+ arguments->insertRows = atoi(argv[++i]);
} else if (0 == strncmp(argv[i], "--records=", strlen("--records="))) {
if (isStringNumber((char *)(argv[i] + strlen("--records=")))) {
- arguments->num_of_DPT = atoi((char *)(argv[i]+strlen("--records=")));
+ arguments->insertRows = atoi((char *)(argv[i]+strlen("--records=")));
} else {
errorPrintReqArg2(argv[0], "--records");
exit(EXIT_FAILURE);
}
} else if (0 == strncmp(argv[i], "-n", strlen("-n"))) {
if (isStringNumber((char *)(argv[i] + strlen("-n")))) {
- arguments->num_of_DPT = atoi((char *)(argv[i]+strlen("-n")));
+ arguments->insertRows = atoi((char *)(argv[i]+strlen("-n")));
} else {
errorPrintReqArg2(argv[0], "-n");
exit(EXIT_FAILURE);
@@ -1422,9 +1448,9 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
errorPrintReqArg2(argv[0], "--records");
exit(EXIT_FAILURE);
}
- arguments->num_of_DPT = atoi(argv[++i]);
+ arguments->insertRows = atoi(argv[++i]);
} else {
- errorUnreconized(argv[0], argv[i]);
+ errorUnrecognized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
} else if ((0 == strncmp(argv[i], "-d", strlen("-d")))
@@ -1446,7 +1472,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
}
arguments->database = argv[++i];
} else {
- errorUnreconized(argv[0], argv[i]);
+ errorUnrecognized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
} else if ((0 == strncmp(argv[i], "-l", strlen("-l")))
@@ -1460,17 +1486,17 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
errorPrintReqArg2(argv[0], "l");
exit(EXIT_FAILURE);
}
- arguments->num_of_CPR = atoi(argv[++i]);
+ arguments->columnCount = atoi(argv[++i]);
} else if (0 == strncmp(argv[i], "--columns=", strlen("--columns="))) {
if (isStringNumber((char *)(argv[i] + strlen("--columns=")))) {
- arguments->num_of_CPR = atoi((char *)(argv[i]+strlen("--columns=")));
+ arguments->columnCount = atoi((char *)(argv[i]+strlen("--columns=")));
} else {
errorPrintReqArg2(argv[0], "--columns");
exit(EXIT_FAILURE);
}
} else if (0 == strncmp(argv[i], "-l", strlen("-l"))) {
if (isStringNumber((char *)(argv[i] + strlen("-l")))) {
- arguments->num_of_CPR = atoi((char *)(argv[i]+strlen("-l")));
+ arguments->columnCount = atoi((char *)(argv[i]+strlen("-l")));
} else {
errorPrintReqArg2(argv[0], "-l");
exit(EXIT_FAILURE);
@@ -1483,23 +1509,25 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
errorPrintReqArg2(argv[0], "--columns");
exit(EXIT_FAILURE);
}
- arguments->num_of_CPR = atoi(argv[++i]);
+ arguments->columnCount = atoi(argv[++i]);
} else {
- errorUnreconized(argv[0], argv[i]);
+ errorUnrecognized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
- if (arguments->num_of_CPR > MAX_NUM_COLUMNS) {
- printf("WARNING: max acceptible columns count is %d\n", MAX_NUM_COLUMNS);
+ if (arguments->columnCount > MAX_NUM_COLUMNS) {
+ printf("WARNING: max acceptable columns count is %d\n", MAX_NUM_COLUMNS);
prompt();
- arguments->num_of_CPR = MAX_NUM_COLUMNS;
+ arguments->columnCount = MAX_NUM_COLUMNS;
}
- for (int col = DEFAULT_DATATYPE_NUM; col < arguments->num_of_CPR; col ++) {
- arguments->datatype[col] = "INT";
+ for (int col = DEFAULT_DATATYPE_NUM; col < arguments->columnCount; col ++) {
+ arguments->dataType[col] = "INT";
+ arguments->data_type[col] = TSDB_DATA_TYPE_INT;
}
- for (int col = arguments->num_of_CPR; col < MAX_NUM_COLUMNS; col++) {
- arguments->datatype[col] = NULL;
+ for (int col = arguments->columnCount; col < MAX_NUM_COLUMNS; col++) {
+ arguments->dataType[col] = NULL;
+ arguments->data_type[col] = TSDB_DATA_TYPE_NULL;
}
} else if ((0 == strncmp(argv[i], "-b", strlen("-b")))
|| (0 == strncmp(argv[i], "--data-type", strlen("--data-type")))) {
@@ -1523,7 +1551,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
}
dataType = argv[++i];
} else {
- errorUnreconized(argv[0], argv[i]);
+ errorUnrecognized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
@@ -1543,8 +1571,32 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
errorPrint("%s", "-b: Invalid data_type!\n");
exit(EXIT_FAILURE);
}
- arguments->datatype[0] = dataType;
- arguments->datatype[1] = NULL;
+ arguments->dataType[0] = dataType;
+ if (0 == strcasecmp(dataType, "INT")) {
+ arguments->data_type[0] = TSDB_DATA_TYPE_INT;
+ } else if (0 == strcasecmp(dataType, "TINYINT")) {
+ arguments->data_type[0] = TSDB_DATA_TYPE_TINYINT;
+ } else if (0 == strcasecmp(dataType, "SMALLINT")) {
+ arguments->data_type[0] = TSDB_DATA_TYPE_SMALLINT;
+ } else if (0 == strcasecmp(dataType, "BIGINT")) {
+ arguments->data_type[0] = TSDB_DATA_TYPE_BIGINT;
+ } else if (0 == strcasecmp(dataType, "FLOAT")) {
+ arguments->data_type[0] = TSDB_DATA_TYPE_FLOAT;
+ } else if (0 == strcasecmp(dataType, "DOUBLE")) {
+ arguments->data_type[0] = TSDB_DATA_TYPE_DOUBLE;
+ } else if (0 == strcasecmp(dataType, "BINARY")) {
+ arguments->data_type[0] = TSDB_DATA_TYPE_BINARY;
+ } else if (0 == strcasecmp(dataType, "NCHAR")) {
+ arguments->data_type[0] = TSDB_DATA_TYPE_NCHAR;
+ } else if (0 == strcasecmp(dataType, "BOOL")) {
+ arguments->data_type[0] = TSDB_DATA_TYPE_BOOL;
+ } else if (0 == strcasecmp(dataType, "TIMESTAMP")) {
+ arguments->data_type[0] = TSDB_DATA_TYPE_TIMESTAMP;
+ } else {
+ arguments->data_type[0] = TSDB_DATA_TYPE_NULL;
+ }
+ arguments->dataType[1] = NULL;
+ arguments->data_type[1] = TSDB_DATA_TYPE_NULL;
} else {
// more than one col
int index = 0;
@@ -1567,11 +1619,37 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
errorPrint("%s", "-b: Invalid data_type!\n");
exit(EXIT_FAILURE);
}
- arguments->datatype[index++] = token;
+
+ if (0 == strcasecmp(token, "INT")) {
+ arguments->data_type[index] = TSDB_DATA_TYPE_INT;
+ } else if (0 == strcasecmp(token, "FLOAT")) {
+ arguments->data_type[index] = TSDB_DATA_TYPE_FLOAT;
+ } else if (0 == strcasecmp(token, "SMALLINT")) {
+ arguments->data_type[index] = TSDB_DATA_TYPE_SMALLINT;
+ } else if (0 == strcasecmp(token, "BIGINT")) {
+ arguments->data_type[index] = TSDB_DATA_TYPE_BIGINT;
+ } else if (0 == strcasecmp(token, "DOUBLE")) {
+ arguments->data_type[index] = TSDB_DATA_TYPE_FLOAT;
+ } else if (0 == strcasecmp(token, "TINYINT")) {
+ arguments->data_type[index] = TSDB_DATA_TYPE_TINYINT;
+ } else if (0 == strcasecmp(token, "BINARY")) {
+ arguments->data_type[index] = TSDB_DATA_TYPE_BINARY;
+ } else if (0 == strcasecmp(token, "NCHAR")) {
+ arguments->data_type[index] = TSDB_DATA_TYPE_NCHAR;
+ } else if (0 == strcasecmp(token, "BOOL")) {
+ arguments->data_type[index] = TSDB_DATA_TYPE_BOOL;
+ } else if (0 == strcasecmp(token, "TIMESTAMP")) {
+ arguments->data_type[index] = TSDB_DATA_TYPE_TIMESTAMP;
+ } else {
+ arguments->data_type[index] = TSDB_DATA_TYPE_NULL;
+ }
+ arguments->dataType[index] = token;
+ index ++;
token = strsep(&running, ",");
if (index >= MAX_NUM_COLUMNS) break;
}
- arguments->datatype[index] = NULL;
+ arguments->dataType[index] = NULL;
+ arguments->data_type[index] = TSDB_DATA_TYPE_NULL;
}
} else if ((0 == strncmp(argv[i], "-w", strlen("-w")))
|| (0 == strncmp(argv[i], "--binwidth", strlen("--binwidth")))) {
@@ -1608,7 +1686,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
}
arguments->binwidth = atoi(argv[++i]);
} else {
- errorUnreconized(argv[0], argv[i]);
+ errorUnrecognized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
} else if ((0 == strncmp(argv[i], "-m", strlen("-m")))
@@ -1630,7 +1708,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
}
arguments->tb_prefix = argv[++i];
} else {
- errorUnreconized(argv[0], argv[i]);
+ errorUnrecognized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
} else if ((strcmp(argv[i], "-N") == 0)
@@ -1695,7 +1773,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
}
arguments->disorderRange = atoi(argv[++i]);
} else {
- errorUnreconized(argv[0], argv[i]);
+ errorUnrecognized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
} else if ((0 == strncmp(argv[i], "-O", strlen("-O")))
@@ -1733,7 +1811,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
}
arguments->disorderRatio = atoi(argv[++i]);
} else {
- errorUnreconized(argv[0], argv[i]);
+ errorUnrecognized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
@@ -1787,7 +1865,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
}
arguments->replica = atoi(argv[++i]);
} else {
- errorUnreconized(argv[0], argv[i]);
+ errorUnrecognized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
@@ -1799,7 +1877,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
} else if (strcmp(argv[i], "-D") == 0) {
arguments->method_of_delete = atoi(argv[++i]);
if (arguments->method_of_delete > 3) {
- errorPrint("%s", "\n\t-D need a valud (0~3) number following!\n");
+ errorPrint("%s", "\n\t-D need a value (0~3) number following!\n");
exit(EXIT_FAILURE);
}
} else if ((strcmp(argv[i], "--version") == 0)
@@ -1814,7 +1892,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
printf(" Usage: taosdemo [-f JSONFILE] [-u USER] [-p PASSWORD] [-c CONFIG_DIR]\n\
[-h HOST] [-P PORT] [-I INTERFACE] [-d DATABASE] [-a REPLICA]\n\
[-m TABLEPREFIX] [-s SQLFILE] [-N] [-o OUTPUTFILE] [-q QUERYMODE]\n\
- [-b DATATYPES] [-w WIDTH_OF_BINARY] [-l COLUNNS] [-T THREADNUMBER]\n\
+ [-b DATATYPES] [-w WIDTH_OF_BINARY] [-l COLUMNS] [-T THREADNUMBER]\n\
[-i SLEEPTIME] [-S TIME_STEP] [-B INTERLACE_ROWS] [-t TABLES]\n\
[-n RECORDS] [-M] [-x] [-y] [-O ORDERMODE] [-R RANGE] [-a REPLIcA][-g]\n\
[--help] [--usage] [--version]\n");
@@ -1842,7 +1920,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
int columnCount;
for (columnCount = 0; columnCount < MAX_NUM_COLUMNS; columnCount ++) {
- if (g_args.datatype[columnCount] == NULL) {
+ if (g_args.dataType[columnCount] == NULL) {
break;
}
}
@@ -1850,7 +1928,56 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
if (0 == columnCount) {
ERROR_EXIT("data type error!");
}
- g_args.num_of_CPR = columnCount;
+ g_args.columnCount = columnCount;
+
+ g_args.lenOfOneRow = 20; // timestamp
+ for (int c = 0; c < g_args.columnCount; c++) {
+ switch(g_args.data_type[c]) {
+ case TSDB_DATA_TYPE_BINARY:
+ g_args.lenOfOneRow += g_args.binwidth + 3;
+ break;
+
+ case TSDB_DATA_TYPE_NCHAR:
+ g_args.lenOfOneRow += g_args.binwidth + 3;
+ break;
+
+ case TSDB_DATA_TYPE_INT:
+ g_args.lenOfOneRow += INT_BUFF_LEN;
+ break;
+
+ case TSDB_DATA_TYPE_BIGINT:
+ g_args.lenOfOneRow += BIGINT_BUFF_LEN;
+ break;
+
+ case TSDB_DATA_TYPE_SMALLINT:
+ g_args.lenOfOneRow += SMALLINT_BUFF_LEN;
+ break;
+
+ case TSDB_DATA_TYPE_TINYINT:
+ g_args.lenOfOneRow += TINYINT_BUFF_LEN;
+ break;
+
+ case TSDB_DATA_TYPE_BOOL:
+ g_args.lenOfOneRow += BOOL_BUFF_LEN;
+ break;
+
+ case TSDB_DATA_TYPE_FLOAT:
+ g_args.lenOfOneRow += FLOAT_BUFF_LEN;
+ break;
+
+ case TSDB_DATA_TYPE_DOUBLE:
+ g_args.lenOfOneRow += DOUBLE_BUFF_LEN;
+ break;
+
+ case TSDB_DATA_TYPE_TIMESTAMP:
+ g_args.lenOfOneRow += TIMESTAMP_BUFF_LEN;
+ break;
+
+ default:
+ errorPrint2("get error data type : %s\n", g_args.dataType[c]);
+ exit(EXIT_FAILURE);
+ }
+ }
if (((arguments->debug_print) && (NULL != arguments->metaFile))
|| arguments->verbose_print) {
@@ -1863,11 +1990,11 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
printf("# Password: %s\n", arguments->password);
printf("# Use metric: %s\n",
arguments->use_metric ? "true" : "false");
- if (*(arguments->datatype)) {
+ if (*(arguments->dataType)) {
printf("# Specified data type: ");
for (int c = 0; c < MAX_NUM_COLUMNS; c++)
- if (arguments->datatype[c])
- printf("%s,", arguments->datatype[c]);
+ if (arguments->dataType[c])
+ printf("%s,", arguments->dataType[c]);
else
break;
printf("\n");
@@ -1875,15 +2002,15 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
printf("# Insertion interval: %"PRIu64"\n",
arguments->insert_interval);
printf("# Number of records per req: %u\n",
- arguments->num_of_RPR);
+ arguments->reqPerReq);
printf("# Max SQL length: %"PRIu64"\n",
arguments->max_sql_len);
printf("# Length of Binary: %d\n", arguments->binwidth);
- printf("# Number of Threads: %d\n", arguments->num_of_threads);
+ printf("# Number of Threads: %d\n", arguments->nthreads);
printf("# Number of Tables: %"PRId64"\n",
- arguments->num_of_tables);
+ arguments->ntables);
printf("# Number of Data per Table: %"PRId64"\n",
- arguments->num_of_DPT);
+ arguments->insertRows);
printf("# Database name: %s\n", arguments->database);
printf("# Table prefix: %s\n", arguments->tb_prefix);
if (arguments->disorderRatio) {
@@ -1909,31 +2036,20 @@ static void tmfclose(FILE *fp) {
static void tmfree(char *buf) {
if (NULL != buf) {
free(buf);
+ buf = NULL;
}
}
static int queryDbExec(TAOS *taos, char *command, QUERY_TYPE type, bool quiet) {
- int i;
- TAOS_RES *res = NULL;
- int32_t code = -1;
- for (i = 0; i < 5 /* retry */; i++) {
- if (NULL != res) {
- taos_free_result(res);
- res = NULL;
- }
+ verbosePrint("%s() LN%d - command: %s\n", __func__, __LINE__, command);
- res = taos_query(taos, command);
- code = taos_errno(res);
- if (0 == code) {
- break;
- }
- }
+ TAOS_RES *res = taos_query(taos, command);
+ int32_t code = taos_errno(res);
- verbosePrint("%s() LN%d - command: %s\n", __func__, __LINE__, command);
if (code != 0) {
if (!quiet) {
- errorPrint2("Failed to execute %s, reason: %s\n",
+ errorPrint2("Failed to execute <%s>, reason: %s\n",
command, taos_errstr(res));
}
taos_free_result(res);
@@ -2338,7 +2454,7 @@ static int printfInsertMeta() {
printf("top insert interval: \033[33m%"PRIu64"\033[0m\n",
g_args.insert_interval);
printf("number of records per req: \033[33m%u\033[0m\n",
- g_args.num_of_RPR);
+ g_args.reqPerReq);
printf("max sql length: \033[33m%"PRIu64"\033[0m\n",
g_args.max_sql_len);
@@ -2349,9 +2465,9 @@ static int printfInsertMeta() {
printf(" database[%d] name: \033[33m%s\033[0m\n",
i, g_Dbs.db[i].dbName);
if (0 == g_Dbs.db[i].drop) {
- printf(" drop: \033[33mno\033[0m\n");
+ printf(" drop: \033[33m no\033[0m\n");
} else {
- printf(" drop: \033[33myes\033[0m\n");
+ printf(" drop: \033[33m yes\033[0m\n");
}
if (g_Dbs.db[i].dbCfg.blocks > 0) {
@@ -2420,7 +2536,7 @@ static int printfInsertMeta() {
printf(" super table[\033[33m%"PRIu64"\033[0m]:\n", j);
printf(" stbName: \033[33m%s\033[0m\n",
- g_Dbs.db[i].superTbls[j].sTblName);
+ g_Dbs.db[i].superTbls[j].stbName);
if (PRE_CREATE_SUBTBL == g_Dbs.db[i].superTbls[j].autoCreateTable) {
printf(" autoCreateTable: \033[33m%s\033[0m\n", "no");
@@ -2460,9 +2576,9 @@ static int printfInsertMeta() {
g_Dbs.db[i].superTbls[j].insertRows);
/*
if (0 == g_Dbs.db[i].superTbls[j].multiThreadWriteOneTbl) {
- printf(" multiThreadWriteOneTbl: \033[33mno\033[0m\n");
+ printf(" multiThreadWriteOneTbl: \033[33m no\033[0m\n");
}else {
- printf(" multiThreadWriteOneTbl: \033[33myes\033[0m\n");
+ printf(" multiThreadWriteOneTbl: \033[33m yes\033[0m\n");
}
*/
printf(" interlaceRows: \033[33m%u\033[0m\n",
@@ -2543,7 +2659,7 @@ static void printfInsertMetaToFile(FILE* fp) {
fprintf(fp, "resultFile: %s\n", g_Dbs.resultFile);
fprintf(fp, "thread num of insert data: %d\n", g_Dbs.threadCount);
fprintf(fp, "thread num of create table: %d\n", g_Dbs.threadCountForCreateTbl);
- fprintf(fp, "number of records per req: %u\n", g_args.num_of_RPR);
+ fprintf(fp, "number of records per req: %u\n", g_args.reqPerReq);
fprintf(fp, "max sql length: %"PRIu64"\n", g_args.max_sql_len);
fprintf(fp, "database count: %d\n", g_Dbs.dbCount);
@@ -2610,7 +2726,7 @@ static void printfInsertMetaToFile(FILE* fp) {
fprintf(fp, " super table[%d]:\n", j);
fprintf(fp, " stbName: %s\n",
- g_Dbs.db[i].superTbls[j].sTblName);
+ g_Dbs.db[i].superTbls[j].stbName);
if (PRE_CREATE_SUBTBL == g_Dbs.db[i].superTbls[j].autoCreateTable) {
fprintf(fp, " autoCreateTable: %s\n", "no");
@@ -2769,7 +2885,7 @@ static void printfQueryMeta() {
printf("childTblCount: \033[33m%"PRId64"\033[0m\n",
g_queryInfo.superQueryInfo.childTblCount);
printf("stable name: \033[33m%s\033[0m\n",
- g_queryInfo.superQueryInfo.sTblName);
+ g_queryInfo.superQueryInfo.stbName);
printf("stb query times:\033[33m%"PRIu64"\033[0m\n",
g_queryInfo.superQueryInfo.queryTimes);
@@ -2840,36 +2956,45 @@ static void xDumpFieldToFile(FILE* fp, const char* val,
char buf[TSDB_MAX_BYTES_PER_ROW];
switch (field->type) {
case TSDB_DATA_TYPE_BOOL:
- fprintf(fp, "%d", ((((int32_t)(*((char *)val))) == 1) ? 1 : 0));
+ fprintf(fp, "%d", ((((int32_t)(*((int8_t*)val))) == 1) ? 1 : 0));
break;
+
case TSDB_DATA_TYPE_TINYINT:
fprintf(fp, "%d", *((int8_t *)val));
break;
+
case TSDB_DATA_TYPE_SMALLINT:
fprintf(fp, "%d", *((int16_t *)val));
break;
+
case TSDB_DATA_TYPE_INT:
fprintf(fp, "%d", *((int32_t *)val));
break;
+
case TSDB_DATA_TYPE_BIGINT:
fprintf(fp, "%"PRId64"", *((int64_t *)val));
break;
+
case TSDB_DATA_TYPE_FLOAT:
fprintf(fp, "%.5f", GET_FLOAT_VAL(val));
break;
+
case TSDB_DATA_TYPE_DOUBLE:
fprintf(fp, "%.9f", GET_DOUBLE_VAL(val));
break;
+
case TSDB_DATA_TYPE_BINARY:
case TSDB_DATA_TYPE_NCHAR:
memcpy(buf, val, length);
buf[length] = 0;
fprintf(fp, "\'%s\'", buf);
break;
+
case TSDB_DATA_TYPE_TIMESTAMP:
formatTimestamp(buf, *(int64_t*)val, precision);
fprintf(fp, "'%s'", buf);
break;
+
default:
break;
}
@@ -3356,29 +3481,50 @@ static int calcRowLen(SSuperTable* superTbls) {
for (colIndex = 0; colIndex < superTbls->columnCount; colIndex++) {
char* dataType = superTbls->columns[colIndex].dataType;
- if (strcasecmp(dataType, "BINARY") == 0) {
- lenOfOneRow += superTbls->columns[colIndex].dataLen + 3;
- } else if (strcasecmp(dataType, "NCHAR") == 0) {
- lenOfOneRow += superTbls->columns[colIndex].dataLen + 3;
- } else if (strcasecmp(dataType, "INT") == 0) {
- lenOfOneRow += INT_BUFF_LEN;
- } else if (strcasecmp(dataType, "BIGINT") == 0) {
- lenOfOneRow += BIGINT_BUFF_LEN;
- } else if (strcasecmp(dataType, "SMALLINT") == 0) {
- lenOfOneRow += SMALLINT_BUFF_LEN;
- } else if (strcasecmp(dataType, "TINYINT") == 0) {
- lenOfOneRow += TINYINT_BUFF_LEN;
- } else if (strcasecmp(dataType, "BOOL") == 0) {
- lenOfOneRow += BOOL_BUFF_LEN;
- } else if (strcasecmp(dataType, "FLOAT") == 0) {
- lenOfOneRow += FLOAT_BUFF_LEN;
- } else if (strcasecmp(dataType, "DOUBLE") == 0) {
- lenOfOneRow += DOUBLE_BUFF_LEN;
- } else if (strcasecmp(dataType, "TIMESTAMP") == 0) {
- lenOfOneRow += TIMESTAMP_BUFF_LEN;
- } else {
- errorPrint2("get error data type : %s\n", dataType);
- exit(EXIT_FAILURE);
+ switch(superTbls->columns[colIndex].data_type) {
+ case TSDB_DATA_TYPE_BINARY:
+ lenOfOneRow += superTbls->columns[colIndex].dataLen + 3;
+ break;
+
+ case TSDB_DATA_TYPE_NCHAR:
+ lenOfOneRow += superTbls->columns[colIndex].dataLen + 3;
+ break;
+
+ case TSDB_DATA_TYPE_INT:
+ lenOfOneRow += INT_BUFF_LEN;
+ break;
+
+ case TSDB_DATA_TYPE_BIGINT:
+ lenOfOneRow += BIGINT_BUFF_LEN;
+ break;
+
+ case TSDB_DATA_TYPE_SMALLINT:
+ lenOfOneRow += SMALLINT_BUFF_LEN;
+ break;
+
+ case TSDB_DATA_TYPE_TINYINT:
+ lenOfOneRow += TINYINT_BUFF_LEN;
+ break;
+
+ case TSDB_DATA_TYPE_BOOL:
+ lenOfOneRow += BOOL_BUFF_LEN;
+ break;
+
+ case TSDB_DATA_TYPE_FLOAT:
+ lenOfOneRow += FLOAT_BUFF_LEN;
+ break;
+
+ case TSDB_DATA_TYPE_DOUBLE:
+ lenOfOneRow += DOUBLE_BUFF_LEN;
+ break;
+
+ case TSDB_DATA_TYPE_TIMESTAMP:
+ lenOfOneRow += TIMESTAMP_BUFF_LEN;
+ break;
+
+ default:
+ errorPrint2("get error data type : %s\n", dataType);
+ exit(EXIT_FAILURE);
}
}
@@ -3418,9 +3564,8 @@ static int calcRowLen(SSuperTable* superTbls) {
return 0;
}
-
static int getChildNameOfSuperTableWithLimitAndOffset(TAOS * taos,
- char* dbName, char* sTblName, char** childTblNameOfSuperTbl,
+ char* dbName, char* stbName, char** childTblNameOfSuperTbl,
int64_t* childTblCountOfSuperTbl, int64_t limit, uint64_t offset) {
char command[1024] = "\0";
@@ -3438,7 +3583,7 @@ static int getChildNameOfSuperTableWithLimitAndOffset(TAOS * taos,
//get all child table name use cmd: select tbname from superTblName;
snprintf(command, 1024, "select tbname from %s.%s %s",
- dbName, sTblName, limitBuf);
+ dbName, stbName, limitBuf);
res = taos_query(taos, command);
int32_t code = taos_errno(res);
@@ -3489,7 +3634,7 @@ static int getChildNameOfSuperTableWithLimitAndOffset(TAOS * taos,
taos_free_result(res);
taos_close(taos);
errorPrint2("%s() LN%d, realloc fail for save child table name of %s.%s\n",
- __func__, __LINE__, dbName, sTblName);
+ __func__, __LINE__, dbName, stbName);
exit(EXIT_FAILURE);
}
}
@@ -3504,10 +3649,10 @@ static int getChildNameOfSuperTableWithLimitAndOffset(TAOS * taos,
}
static int getAllChildNameOfSuperTable(TAOS * taos, char* dbName,
- char* sTblName, char** childTblNameOfSuperTbl,
+ char* stbName, char** childTblNameOfSuperTbl,
int64_t* childTblCountOfSuperTbl) {
- return getChildNameOfSuperTableWithLimitAndOffset(taos, dbName, sTblName,
+ return getChildNameOfSuperTableWithLimitAndOffset(taos, dbName, stbName,
childTblNameOfSuperTbl, childTblCountOfSuperTbl,
-1, 0);
}
@@ -3521,7 +3666,7 @@ static int getSuperTableFromServer(TAOS * taos, char* dbName,
int count = 0;
//get schema use cmd: describe superTblName;
- snprintf(command, 1024, "describe %s.%s", dbName, superTbls->sTblName);
+ snprintf(command, 1024, "describe %s.%s", dbName, superTbls->stbName);
res = taos_query(taos, command);
int32_t code = taos_errno(res);
if (code != 0) {
@@ -3547,6 +3692,39 @@ static int getSuperTableFromServer(TAOS * taos, char* dbName,
(char *)row[TSDB_DESCRIBE_METRIC_TYPE_INDEX],
min(DATATYPE_BUFF_LEN,
fields[TSDB_DESCRIBE_METRIC_TYPE_INDEX].bytes) + 1);
+ if (0 == strncasecmp(superTbls->tags[tagIndex].dataType,
+ "INT", strlen("INT"))) {
+ superTbls->tags[tagIndex].data_type = TSDB_DATA_TYPE_INT;
+ } else if (0 == strncasecmp(superTbls->tags[tagIndex].dataType,
+ "TINYINT", strlen("TINYINT"))) {
+ superTbls->tags[tagIndex].data_type = TSDB_DATA_TYPE_TINYINT;
+ } else if (0 == strncasecmp(superTbls->tags[tagIndex].dataType,
+ "SMALLINT", strlen("SMALLINT"))) {
+ superTbls->tags[tagIndex].data_type = TSDB_DATA_TYPE_SMALLINT;
+ } else if (0 == strncasecmp(superTbls->tags[tagIndex].dataType,
+ "BIGINT", strlen("BIGINT"))) {
+ superTbls->tags[tagIndex].data_type = TSDB_DATA_TYPE_BIGINT;
+ } else if (0 == strncasecmp(superTbls->tags[tagIndex].dataType,
+ "FLOAT", strlen("FLOAT"))) {
+ superTbls->tags[tagIndex].data_type = TSDB_DATA_TYPE_FLOAT;
+ } else if (0 == strncasecmp(superTbls->tags[tagIndex].dataType,
+ "DOUBLE", strlen("DOUBLE"))) {
+ superTbls->tags[tagIndex].data_type = TSDB_DATA_TYPE_DOUBLE;
+ } else if (0 == strncasecmp(superTbls->tags[tagIndex].dataType,
+ "BINARY", strlen("BINARY"))) {
+ superTbls->tags[tagIndex].data_type = TSDB_DATA_TYPE_BINARY;
+ } else if (0 == strncasecmp(superTbls->tags[tagIndex].dataType,
+ "NCHAR", strlen("NCHAR"))) {
+ superTbls->tags[tagIndex].data_type = TSDB_DATA_TYPE_NCHAR;
+ } else if (0 == strncasecmp(superTbls->tags[tagIndex].dataType,
+ "BOOL", strlen("BOOL"))) {
+ superTbls->tags[tagIndex].data_type = TSDB_DATA_TYPE_BOOL;
+ } else if (0 == strncasecmp(superTbls->tags[tagIndex].dataType,
+ "TIMESTAMP", strlen("TIMESTAMP"))) {
+ superTbls->tags[tagIndex].data_type = TSDB_DATA_TYPE_TIMESTAMP;
+ } else {
+ superTbls->tags[tagIndex].data_type = TSDB_DATA_TYPE_NULL;
+ }
superTbls->tags[tagIndex].dataLen =
*((int *)row[TSDB_DESCRIBE_METRIC_LENGTH_INDEX]);
tstrncpy(superTbls->tags[tagIndex].note,
@@ -3558,16 +3736,51 @@ static int getSuperTableFromServer(TAOS * taos, char* dbName,
tstrncpy(superTbls->columns[columnIndex].field,
(char *)row[TSDB_DESCRIBE_METRIC_FIELD_INDEX],
fields[TSDB_DESCRIBE_METRIC_FIELD_INDEX].bytes);
+
tstrncpy(superTbls->columns[columnIndex].dataType,
(char *)row[TSDB_DESCRIBE_METRIC_TYPE_INDEX],
min(DATATYPE_BUFF_LEN,
fields[TSDB_DESCRIBE_METRIC_TYPE_INDEX].bytes) + 1);
+ if (0 == strncasecmp(superTbls->columns[columnIndex].dataType,
+ "INT", strlen("INT"))) {
+ superTbls->columns[columnIndex].data_type = TSDB_DATA_TYPE_INT;
+ } else if (0 == strncasecmp(superTbls->columns[columnIndex].dataType,
+ "TINYINT", strlen("TINYINT"))) {
+ superTbls->columns[columnIndex].data_type = TSDB_DATA_TYPE_TINYINT;
+ } else if (0 == strncasecmp(superTbls->columns[columnIndex].dataType,
+ "SMALLINT", strlen("SMALLINT"))) {
+ superTbls->columns[columnIndex].data_type = TSDB_DATA_TYPE_SMALLINT;
+ } else if (0 == strncasecmp(superTbls->columns[columnIndex].dataType,
+ "BIGINT", strlen("BIGINT"))) {
+ superTbls->columns[columnIndex].data_type = TSDB_DATA_TYPE_BIGINT;
+ } else if (0 == strncasecmp(superTbls->columns[columnIndex].dataType,
+ "FLOAT", strlen("FLOAT"))) {
+ superTbls->columns[columnIndex].data_type = TSDB_DATA_TYPE_FLOAT;
+ } else if (0 == strncasecmp(superTbls->columns[columnIndex].dataType,
+ "DOUBLE", strlen("DOUBLE"))) {
+ superTbls->columns[columnIndex].data_type = TSDB_DATA_TYPE_DOUBLE;
+ } else if (0 == strncasecmp(superTbls->columns[columnIndex].dataType,
+ "BINARY", strlen("BINARY"))) {
+ superTbls->columns[columnIndex].data_type = TSDB_DATA_TYPE_BINARY;
+ } else if (0 == strncasecmp(superTbls->columns[columnIndex].dataType,
+ "NCHAR", strlen("NCHAR"))) {
+ superTbls->columns[columnIndex].data_type = TSDB_DATA_TYPE_NCHAR;
+ } else if (0 == strncasecmp(superTbls->columns[columnIndex].dataType,
+ "BOOL", strlen("BOOL"))) {
+ superTbls->columns[columnIndex].data_type = TSDB_DATA_TYPE_BOOL;
+ } else if (0 == strncasecmp(superTbls->columns[columnIndex].dataType,
+ "TIMESTAMP", strlen("TIMESTAMP"))) {
+ superTbls->columns[columnIndex].data_type = TSDB_DATA_TYPE_TIMESTAMP;
+ } else {
+ superTbls->columns[columnIndex].data_type = TSDB_DATA_TYPE_NULL;
+ }
superTbls->columns[columnIndex].dataLen =
*((int *)row[TSDB_DESCRIBE_METRIC_LENGTH_INDEX]);
tstrncpy(superTbls->columns[columnIndex].note,
(char *)row[TSDB_DESCRIBE_METRIC_NOTE_INDEX],
min(NOTE_BUFF_LEN,
fields[TSDB_DESCRIBE_METRIC_NOTE_INDEX].bytes) + 1);
+
columnIndex++;
}
count++;
@@ -3589,7 +3802,7 @@ static int getSuperTableFromServer(TAOS * taos, char* dbName,
return -1;
}
getAllChildNameOfSuperTable(taos, dbName,
- superTbls->sTblName,
+ superTbls->stbName,
&superTbls->childTblName,
&superTbls->childTblCount);
}
@@ -3605,7 +3818,6 @@ static int createSuperTable(
assert(command);
char cols[COL_BUFFER_LEN] = "\0";
- int colIndex;
int len = 0;
int lenOfOneRow = 0;
@@ -3617,67 +3829,87 @@ static int createSuperTable(
return -1;
}
- for (colIndex = 0; colIndex < superTbl->columnCount; colIndex++) {
- char* dataType = superTbl->columns[colIndex].dataType;
+ for (int colIndex = 0; colIndex < superTbl->columnCount; colIndex++) {
- if (strcasecmp(dataType, "BINARY") == 0) {
- len += snprintf(cols + len, COL_BUFFER_LEN - len,
- ",C%d %s(%d)", colIndex, "BINARY",
- superTbl->columns[colIndex].dataLen);
- lenOfOneRow += superTbl->columns[colIndex].dataLen + 3;
- } else if (strcasecmp(dataType, "NCHAR") == 0) {
- len += snprintf(cols + len, COL_BUFFER_LEN - len,
- ",C%d %s(%d)", colIndex, "NCHAR",
- superTbl->columns[colIndex].dataLen);
- lenOfOneRow += superTbl->columns[colIndex].dataLen + 3;
- } else if (strcasecmp(dataType, "INT") == 0) {
- if ((g_args.demo_mode) && (colIndex == 1)) {
+ switch(superTbl->columns[colIndex].data_type) {
+ case TSDB_DATA_TYPE_BINARY:
len += snprintf(cols + len, COL_BUFFER_LEN - len,
- ", VOLTAGE INT");
- } else {
- len += snprintf(cols + len, COL_BUFFER_LEN - len, ",C%d %s", colIndex, "INT");
- }
- lenOfOneRow += INT_BUFF_LEN;
- } else if (strcasecmp(dataType, "BIGINT") == 0) {
- len += snprintf(cols + len, COL_BUFFER_LEN - len, ",C%d %s",
- colIndex, "BIGINT");
- lenOfOneRow += BIGINT_BUFF_LEN;
- } else if (strcasecmp(dataType, "SMALLINT") == 0) {
- len += snprintf(cols + len, COL_BUFFER_LEN - len, ",C%d %s",
- colIndex, "SMALLINT");
- lenOfOneRow += SMALLINT_BUFF_LEN;
- } else if (strcasecmp(dataType, "TINYINT") == 0) {
- len += snprintf(cols + len, COL_BUFFER_LEN - len, ",C%d %s", colIndex, "TINYINT");
- lenOfOneRow += TINYINT_BUFF_LEN;
- } else if (strcasecmp(dataType, "BOOL") == 0) {
- len += snprintf(cols + len, COL_BUFFER_LEN - len, ",C%d %s", colIndex, "BOOL");
- lenOfOneRow += BOOL_BUFF_LEN;
- } else if (strcasecmp(dataType, "FLOAT") == 0) {
- if (g_args.demo_mode) {
- if (colIndex == 0) {
- len += snprintf(cols + len, COL_BUFFER_LEN - len, ", CURRENT FLOAT");
- } else if (colIndex == 2) {
- len += snprintf(cols + len, COL_BUFFER_LEN - len, ", PHASE FLOAT");
+ ",C%d %s(%d)", colIndex, "BINARY",
+ superTbl->columns[colIndex].dataLen);
+ lenOfOneRow += superTbl->columns[colIndex].dataLen + 3;
+ break;
+
+ case TSDB_DATA_TYPE_NCHAR:
+ len += snprintf(cols + len, COL_BUFFER_LEN - len,
+ ",C%d %s(%d)", colIndex, "NCHAR",
+ superTbl->columns[colIndex].dataLen);
+ lenOfOneRow += superTbl->columns[colIndex].dataLen + 3;
+ break;
+
+ case TSDB_DATA_TYPE_INT:
+ if ((g_args.demo_mode) && (colIndex == 1)) {
+ len += snprintf(cols + len, COL_BUFFER_LEN - len,
+ ", VOLTAGE INT");
+ } else {
+ len += snprintf(cols + len, COL_BUFFER_LEN - len, ",C%d %s", colIndex, "INT");
}
- } else {
- len += snprintf(cols + len, COL_BUFFER_LEN - len, ",C%d %s", colIndex, "FLOAT");
- }
+ lenOfOneRow += INT_BUFF_LEN;
+ break;
- lenOfOneRow += FLOAT_BUFF_LEN;
- } else if (strcasecmp(dataType, "DOUBLE") == 0) {
- len += snprintf(cols + len, COL_BUFFER_LEN - len, ",C%d %s",
- colIndex, "DOUBLE");
- lenOfOneRow += DOUBLE_BUFF_LEN;
- } else if (strcasecmp(dataType, "TIMESTAMP") == 0) {
- len += snprintf(cols + len, COL_BUFFER_LEN - len, ",C%d %s",
- colIndex, "TIMESTAMP");
- lenOfOneRow += TIMESTAMP_BUFF_LEN;
- } else {
- taos_close(taos);
- free(command);
- errorPrint2("%s() LN%d, config error data type : %s\n",
- __func__, __LINE__, dataType);
- exit(EXIT_FAILURE);
+ case TSDB_DATA_TYPE_BIGINT:
+ len += snprintf(cols + len, COL_BUFFER_LEN - len, ",C%d %s",
+ colIndex, "BIGINT");
+ lenOfOneRow += BIGINT_BUFF_LEN;
+ break;
+
+ case TSDB_DATA_TYPE_SMALLINT:
+ len += snprintf(cols + len, COL_BUFFER_LEN - len, ",C%d %s",
+ colIndex, "SMALLINT");
+ lenOfOneRow += SMALLINT_BUFF_LEN;
+ break;
+
+ case TSDB_DATA_TYPE_TINYINT:
+ len += snprintf(cols + len, COL_BUFFER_LEN - len, ",C%d %s", colIndex, "TINYINT");
+ lenOfOneRow += TINYINT_BUFF_LEN;
+ break;
+
+ case TSDB_DATA_TYPE_BOOL:
+ len += snprintf(cols + len, COL_BUFFER_LEN - len, ",C%d %s", colIndex, "BOOL");
+ lenOfOneRow += BOOL_BUFF_LEN;
+ break;
+
+ case TSDB_DATA_TYPE_FLOAT:
+ if (g_args.demo_mode) {
+ if (colIndex == 0) {
+ len += snprintf(cols + len, COL_BUFFER_LEN - len, ", CURRENT FLOAT");
+ } else if (colIndex == 2) {
+ len += snprintf(cols + len, COL_BUFFER_LEN - len, ", PHASE FLOAT");
+ }
+ } else {
+ len += snprintf(cols + len, COL_BUFFER_LEN - len, ",C%d %s", colIndex, "FLOAT");
+ }
+
+ lenOfOneRow += FLOAT_BUFF_LEN;
+ break;
+
+ case TSDB_DATA_TYPE_DOUBLE:
+ len += snprintf(cols + len, COL_BUFFER_LEN - len, ",C%d %s",
+ colIndex, "DOUBLE");
+ lenOfOneRow += DOUBLE_BUFF_LEN;
+ break;
+
+ case TSDB_DATA_TYPE_TIMESTAMP:
+ len += snprintf(cols + len, COL_BUFFER_LEN - len, ",C%d %s",
+ colIndex, "TIMESTAMP");
+ lenOfOneRow += TIMESTAMP_BUFF_LEN;
+ break;
+
+ default:
+ taos_close(taos);
+ free(command);
+ errorPrint2("%s() LN%d, config error data type : %s\n",
+ __func__, __LINE__, superTbl->columns[colIndex].dataType);
+ exit(EXIT_FAILURE);
}
}
@@ -3777,16 +4009,16 @@ static int createSuperTable(
superTbl->lenOfTagOfOneRow = lenOfTagOfOneRow;
snprintf(command, BUFFER_SIZE,
- "create table if not exists %s.%s (ts timestamp%s) tags %s",
- dbName, superTbl->sTblName, cols, tags);
+ "CREATE TABLE IF NOT EXISTS %s.%s (ts TIMESTAMP%s) TAGS %s",
+ dbName, superTbl->stbName, cols, tags);
if (0 != queryDbExec(taos, command, NO_INSERT_TYPE, false)) {
errorPrint2("create supertable %s failed!\n\n",
- superTbl->sTblName);
+ superTbl->stbName);
free(command);
return -1;
}
- debugPrint("create supertable %s success!\n\n", superTbl->sTblName);
+ debugPrint("create supertable %s success!\n\n", superTbl->stbName);
free(command);
return 0;
}
@@ -3810,42 +4042,42 @@ int createDatabasesAndStables(char *command) {
int dataLen = 0;
dataLen += snprintf(command + dataLen,
- BUFFER_SIZE - dataLen, "create database if not exists %s",
+ BUFFER_SIZE - dataLen, "CREATE DATABASE IF NOT EXISTS %s",
g_Dbs.db[i].dbName);
if (g_Dbs.db[i].dbCfg.blocks > 0) {
dataLen += snprintf(command + dataLen,
- BUFFER_SIZE - dataLen, " blocks %d",
+ BUFFER_SIZE - dataLen, " BLOCKS %d",
g_Dbs.db[i].dbCfg.blocks);
}
if (g_Dbs.db[i].dbCfg.cache > 0) {
dataLen += snprintf(command + dataLen,
- BUFFER_SIZE - dataLen, " cache %d",
+ BUFFER_SIZE - dataLen, " CACHE %d",
g_Dbs.db[i].dbCfg.cache);
}
if (g_Dbs.db[i].dbCfg.days > 0) {
dataLen += snprintf(command + dataLen,
- BUFFER_SIZE - dataLen, " days %d",
+ BUFFER_SIZE - dataLen, " DAYS %d",
g_Dbs.db[i].dbCfg.days);
}
if (g_Dbs.db[i].dbCfg.keep > 0) {
dataLen += snprintf(command + dataLen,
- BUFFER_SIZE - dataLen, " keep %d",
+ BUFFER_SIZE - dataLen, " KEEP %d",
g_Dbs.db[i].dbCfg.keep);
}
if (g_Dbs.db[i].dbCfg.quorum > 1) {
dataLen += snprintf(command + dataLen,
- BUFFER_SIZE - dataLen, " quorum %d",
+ BUFFER_SIZE - dataLen, " QUORUM %d",
g_Dbs.db[i].dbCfg.quorum);
}
if (g_Dbs.db[i].dbCfg.replica > 0) {
dataLen += snprintf(command + dataLen,
- BUFFER_SIZE - dataLen, " replica %d",
+ BUFFER_SIZE - dataLen, " REPLICA %d",
g_Dbs.db[i].dbCfg.replica);
}
if (g_Dbs.db[i].dbCfg.update > 0) {
dataLen += snprintf(command + dataLen,
- BUFFER_SIZE - dataLen, " update %d",
+ BUFFER_SIZE - dataLen, " UPDATE %d",
g_Dbs.db[i].dbCfg.update);
}
//if (g_Dbs.db[i].dbCfg.maxtablesPerVnode > 0) {
@@ -3854,17 +4086,17 @@ int createDatabasesAndStables(char *command) {
//}
if (g_Dbs.db[i].dbCfg.minRows > 0) {
dataLen += snprintf(command + dataLen,
- BUFFER_SIZE - dataLen, " minrows %d",
+ BUFFER_SIZE - dataLen, " MINROWS %d",
g_Dbs.db[i].dbCfg.minRows);
}
if (g_Dbs.db[i].dbCfg.maxRows > 0) {
dataLen += snprintf(command + dataLen,
- BUFFER_SIZE - dataLen, " maxrows %d",
+ BUFFER_SIZE - dataLen, " MAXROWS %d",
g_Dbs.db[i].dbCfg.maxRows);
}
if (g_Dbs.db[i].dbCfg.comp > 0) {
dataLen += snprintf(command + dataLen,
- BUFFER_SIZE - dataLen, " comp %d",
+ BUFFER_SIZE - dataLen, " COMP %d",
g_Dbs.db[i].dbCfg.comp);
}
if (g_Dbs.db[i].dbCfg.walLevel > 0) {
@@ -3874,12 +4106,12 @@ int createDatabasesAndStables(char *command) {
}
if (g_Dbs.db[i].dbCfg.cacheLast > 0) {
dataLen += snprintf(command + dataLen,
- BUFFER_SIZE - dataLen, " cachelast %d",
+ BUFFER_SIZE - dataLen, " CACHELAST %d",
g_Dbs.db[i].dbCfg.cacheLast);
}
if (g_Dbs.db[i].dbCfg.fsync > 0) {
dataLen += snprintf(command + dataLen, BUFFER_SIZE - dataLen,
- " fsync %d", g_Dbs.db[i].dbCfg.fsync);
+ " FSYNC %d", g_Dbs.db[i].dbCfg.fsync);
}
if ((0 == strncasecmp(g_Dbs.db[i].dbCfg.precision, "ms", 2))
|| (0 == strncasecmp(g_Dbs.db[i].dbCfg.precision,
@@ -3906,7 +4138,7 @@ int createDatabasesAndStables(char *command) {
for (uint64_t j = 0; j < g_Dbs.db[i].superTblCount; j++) {
sprintf(command, "describe %s.%s;", g_Dbs.db[i].dbName,
- g_Dbs.db[i].superTbls[j].sTblName);
+ g_Dbs.db[i].superTbls[j].stbName);
ret = queryDbExec(taos, command, NO_INSERT_TYPE, true);
if ((ret != 0) || (g_Dbs.db[i].drop)) {
@@ -3923,7 +4155,7 @@ int createDatabasesAndStables(char *command) {
&g_Dbs.db[i].superTbls[j]);
if (0 != ret) {
errorPrint2("\nget super table %s.%s info failed!\n\n",
- g_Dbs.db[i].dbName, g_Dbs.db[i].superTbls[j].sTblName);
+ g_Dbs.db[i].dbName, g_Dbs.db[i].superTbls[j].stbName);
continue;
}
@@ -3965,7 +4197,7 @@ static void* createTable(void *sarg)
i <= pThreadInfo->end_table_to; i++) {
if (0 == g_Dbs.use_metric) {
snprintf(pThreadInfo->buffer, buff_len,
- "create table if not exists %s.%s%"PRIu64" %s;",
+ "CREATE TABLE IF NOT EXISTS %s.%s%"PRIu64" %s;",
pThreadInfo->db_name,
g_args.tb_prefix, i,
pThreadInfo->cols);
@@ -3981,7 +4213,7 @@ static void* createTable(void *sarg)
batchNum = 0;
memset(pThreadInfo->buffer, 0, buff_len);
len += snprintf(pThreadInfo->buffer + len,
- buff_len - len, "create table ");
+ buff_len - len, "CREATE TABLE ");
}
char* tagsValBuf = NULL;
@@ -4006,7 +4238,7 @@ static void* createTable(void *sarg)
"if not exists %s.%s%"PRIu64" using %s.%s tags %s ",
pThreadInfo->db_name, stbInfo->childTblPrefix,
i, pThreadInfo->db_name,
- stbInfo->sTblName, tagsValBuf);
+ stbInfo->stbName, tagsValBuf);
free(tagsValBuf);
batchNum++;
if ((batchNum < stbInfo->batchCreateTableNum)
@@ -4151,15 +4383,15 @@ static void createChildTables() {
} else {
// normal table
len = snprintf(tblColsBuf, TSDB_MAX_BYTES_PER_ROW, "(TS TIMESTAMP");
- for (int j = 0; j < g_args.num_of_CPR; j++) {
- if ((strncasecmp(g_args.datatype[j], "BINARY", strlen("BINARY")) == 0)
- || (strncasecmp(g_args.datatype[j],
+ for (int j = 0; j < g_args.columnCount; j++) {
+ if ((strncasecmp(g_args.dataType[j], "BINARY", strlen("BINARY")) == 0)
+ || (strncasecmp(g_args.dataType[j],
"NCHAR", strlen("NCHAR")) == 0)) {
snprintf(tblColsBuf + len, TSDB_MAX_BYTES_PER_ROW - len,
- ",C%d %s(%d)", j, g_args.datatype[j], g_args.binwidth);
+ ",C%d %s(%d)", j, g_args.dataType[j], g_args.binwidth);
} else {
snprintf(tblColsBuf + len, TSDB_MAX_BYTES_PER_ROW - len,
- ",C%d %s", j, g_args.datatype[j]);
+ ",C%d %s", j, g_args.dataType[j]);
}
len = strlen(tblColsBuf);
}
@@ -4168,12 +4400,12 @@ static void createChildTables() {
verbosePrint("%s() LN%d: dbName: %s num of tb: %"PRId64" schema: %s\n",
__func__, __LINE__,
- g_Dbs.db[i].dbName, g_args.num_of_tables, tblColsBuf);
+ g_Dbs.db[i].dbName, g_args.ntables, tblColsBuf);
startMultiThreadCreateChildTable(
tblColsBuf,
g_Dbs.threadCountForCreateTbl,
0,
- g_args.num_of_tables,
+ g_args.ntables,
g_Dbs.db[i].dbName,
NULL);
}
@@ -4251,7 +4483,7 @@ static int readTagFromCsvFileToMem(SSuperTable * stbInfo) {
/*
Read 10000 lines at most. If more than 10000 lines, continue to read after using
*/
-static int readSampleFromCsvFileToMem(
+static int generateSampleFromCsvForStb(
SSuperTable* stbInfo) {
size_t n = 0;
ssize_t readLen = 0;
@@ -4267,7 +4499,7 @@ static int readSampleFromCsvFileToMem(
assert(stbInfo->sampleDataBuf);
memset(stbInfo->sampleDataBuf, 0,
- MAX_SAMPLES_ONCE_FROM_FILE * stbInfo->lenOfOneRow);
+ MAX_SAMPLES * stbInfo->lenOfOneRow);
while(1) {
readLen = tgetline(&line, &n, fp);
if (-1 == readLen) {
@@ -4298,7 +4530,7 @@ static int readSampleFromCsvFileToMem(
line, readLen);
getRows++;
- if (getRows == MAX_SAMPLES_ONCE_FROM_FILE) {
+ if (getRows == MAX_SAMPLES) {
break;
}
}
@@ -4377,6 +4609,7 @@ static bool getColumnAndTagTypeFromInsertJsonFile(
tstrncpy(superTbls->columns[index].dataType,
columnCase.dataType,
min(DATATYPE_BUFF_LEN, strlen(columnCase.dataType) + 1));
+
superTbls->columns[index].dataLen = columnCase.dataLen;
index++;
}
@@ -4390,6 +4623,42 @@ static bool getColumnAndTagTypeFromInsertJsonFile(
superTbls->columnCount = index;
+ for (int c = 0; c < superTbls->columnCount; c++) {
+ if (0 == strncasecmp(superTbls->columns[c].dataType,
+ "INT", strlen("INT"))) {
+ superTbls->columns[c].data_type = TSDB_DATA_TYPE_INT;
+ } else if (0 == strncasecmp(superTbls->columns[c].dataType,
+ "TINYINT", strlen("TINYINT"))) {
+ superTbls->columns[c].data_type = TSDB_DATA_TYPE_TINYINT;
+ } else if (0 == strncasecmp(superTbls->columns[c].dataType,
+ "SMALLINT", strlen("SMALLINT"))) {
+ superTbls->columns[c].data_type = TSDB_DATA_TYPE_SMALLINT;
+ } else if (0 == strncasecmp(superTbls->columns[c].dataType,
+ "BIGINT", strlen("BIGINT"))) {
+ superTbls->columns[c].data_type = TSDB_DATA_TYPE_BIGINT;
+ } else if (0 == strncasecmp(superTbls->columns[c].dataType,
+ "FLOAT", strlen("FLOAT"))) {
+ superTbls->columns[c].data_type = TSDB_DATA_TYPE_FLOAT;
+ } else if (0 == strncasecmp(superTbls->columns[c].dataType,
+ "DOUBLE", strlen("DOUBLE"))) {
+ superTbls->columns[c].data_type = TSDB_DATA_TYPE_DOUBLE;
+ } else if (0 == strncasecmp(superTbls->columns[c].dataType,
+ "BINARY", strlen("BINARY"))) {
+ superTbls->columns[c].data_type = TSDB_DATA_TYPE_BINARY;
+ } else if (0 == strncasecmp(superTbls->columns[c].dataType,
+ "NCHAR", strlen("NCHAR"))) {
+ superTbls->columns[c].data_type = TSDB_DATA_TYPE_NCHAR;
+ } else if (0 == strncasecmp(superTbls->columns[c].dataType,
+ "BOOL", strlen("BOOL"))) {
+ superTbls->columns[c].data_type = TSDB_DATA_TYPE_BOOL;
+ } else if (0 == strncasecmp(superTbls->columns[c].dataType,
+ "TIMESTAMP", strlen("TIMESTAMP"))) {
+ superTbls->columns[c].data_type = TSDB_DATA_TYPE_TIMESTAMP;
+ } else {
+ superTbls->columns[c].data_type = TSDB_DATA_TYPE_NULL;
+ }
+ }
+
count = 1;
index = 0;
// tags
@@ -4459,6 +4728,42 @@ static bool getColumnAndTagTypeFromInsertJsonFile(
superTbls->tagCount = index;
+ for (int t = 0; t < superTbls->tagCount; t++) {
+ if (0 == strncasecmp(superTbls->tags[t].dataType,
+ "INT", strlen("INT"))) {
+ superTbls->tags[t].data_type = TSDB_DATA_TYPE_INT;
+ } else if (0 == strncasecmp(superTbls->tags[t].dataType,
+ "TINYINT", strlen("TINYINT"))) {
+ superTbls->tags[t].data_type = TSDB_DATA_TYPE_TINYINT;
+ } else if (0 == strncasecmp(superTbls->tags[t].dataType,
+ "SMALLINT", strlen("SMALLINT"))) {
+ superTbls->tags[t].data_type = TSDB_DATA_TYPE_SMALLINT;
+ } else if (0 == strncasecmp(superTbls->tags[t].dataType,
+ "BIGINT", strlen("BIGINT"))) {
+ superTbls->tags[t].data_type = TSDB_DATA_TYPE_BIGINT;
+ } else if (0 == strncasecmp(superTbls->tags[t].dataType,
+ "FLOAT", strlen("FLOAT"))) {
+ superTbls->tags[t].data_type = TSDB_DATA_TYPE_FLOAT;
+ } else if (0 == strncasecmp(superTbls->tags[t].dataType,
+ "DOUBLE", strlen("DOUBLE"))) {
+ superTbls->tags[t].data_type = TSDB_DATA_TYPE_DOUBLE;
+ } else if (0 == strncasecmp(superTbls->tags[t].dataType,
+ "BINARY", strlen("BINARY"))) {
+ superTbls->tags[t].data_type = TSDB_DATA_TYPE_BINARY;
+ } else if (0 == strncasecmp(superTbls->tags[t].dataType,
+ "NCHAR", strlen("NCHAR"))) {
+ superTbls->tags[t].data_type = TSDB_DATA_TYPE_NCHAR;
+ } else if (0 == strncasecmp(superTbls->tags[t].dataType,
+ "BOOL", strlen("BOOL"))) {
+ superTbls->tags[t].data_type = TSDB_DATA_TYPE_BOOL;
+ } else if (0 == strncasecmp(superTbls->tags[t].dataType,
+ "TIMESTAMP", strlen("TIMESTAMP"))) {
+ superTbls->tags[t].data_type = TSDB_DATA_TYPE_TIMESTAMP;
+ } else {
+ superTbls->tags[t].data_type = TSDB_DATA_TYPE_NULL;
+ }
+ }
+
if ((superTbls->columnCount + superTbls->tagCount + 1 /* ts */) > TSDB_MAX_COLUMNS) {
errorPrint("columns + tags is more than allowed max columns count: %d\n",
TSDB_MAX_COLUMNS);
@@ -4553,15 +4858,15 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
cJSON* interlaceRows = cJSON_GetObjectItem(root, "interlace_rows");
if (interlaceRows && interlaceRows->type == cJSON_Number) {
if (interlaceRows->valueint < 0) {
- errorPrint("%s", "failed to read json, interlace_rows input mistake\n");
+ errorPrint("%s", "failed to read json, interlaceRows input mistake\n");
goto PARSE_OVER;
}
- g_args.interlace_rows = interlaceRows->valueint;
+ g_args.interlaceRows = interlaceRows->valueint;
} else if (!interlaceRows) {
- g_args.interlace_rows = 0; // 0 means progressive mode, > 0 mean interlace mode. max value is less or equ num_of_records_per_req
+ g_args.interlaceRows = 0; // 0 means progressive mode, > 0 mean interlace mode. max value is less or equ num_of_records_per_req
} else {
- errorPrint("%s", "failed to read json, interlace_rows input mistake\n");
+ errorPrint("%s", "failed to read json, interlaceRows input mistake\n");
goto PARSE_OVER;
}
@@ -4595,9 +4900,9 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
prompt();
numRecPerReq->valueint = MAX_RECORDS_PER_REQ;
}
- g_args.num_of_RPR = numRecPerReq->valueint;
+ g_args.reqPerReq = numRecPerReq->valueint;
} else if (!numRecPerReq) {
- g_args.num_of_RPR = MAX_RECORDS_PER_REQ;
+ g_args.reqPerReq = MAX_RECORDS_PER_REQ;
} else {
errorPrint("%s() LN%d, failed to read json, num_of_records_per_req not found\n",
__func__, __LINE__);
@@ -4623,13 +4928,13 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
}
// rows per table need be less than insert batch
- if (g_args.interlace_rows > g_args.num_of_RPR) {
+ if (g_args.interlaceRows > g_args.reqPerReq) {
printf("NOTICE: interlace rows value %u > num_of_records_per_req %u\n\n",
- g_args.interlace_rows, g_args.num_of_RPR);
+ g_args.interlaceRows, g_args.reqPerReq);
printf(" interlace rows value will be set to num_of_records_per_req %u\n\n",
- g_args.num_of_RPR);
+ g_args.reqPerReq);
prompt();
- g_args.interlace_rows = g_args.num_of_RPR;
+ g_args.interlaceRows = g_args.reqPerReq;
}
cJSON* dbs = cJSON_GetObjectItem(root, "databases");
@@ -4831,7 +5136,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
goto PARSE_OVER;
}
- // super_talbes
+ // super_tables
cJSON *stables = cJSON_GetObjectItem(dbinfos, "super_tables");
if (!stables || stables->type != cJSON_Array) {
errorPrint("%s", "failed to read json, super_tables not found\n");
@@ -4858,7 +5163,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
errorPrint("%s", "failed to read json, stb name not found\n");
goto PARSE_OVER;
}
- tstrncpy(g_Dbs.db[i].superTbls[j].sTblName, stbName->valuestring,
+ tstrncpy(g_Dbs.db[i].superTbls[j].stbName, stbName->valuestring,
TSDB_TABLE_NAME_LEN);
cJSON *prefix = cJSON_GetObjectItem(stbInfo, "childtable_prefix");
@@ -5168,7 +5473,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
goto PARSE_OVER;
}
} else if (!insertInterval) {
- verbosePrint("%s() LN%d: stable insert interval be overrided by global %"PRIu64".\n",
+ verbosePrint("%s() LN%d: stable insert interval be overrode by global %"PRIu64".\n",
__func__, __LINE__, g_args.insert_interval);
g_Dbs.db[i].superTbls[j].insertInterval = g_args.insert_interval;
} else {
@@ -5512,7 +5817,7 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
cJSON* stblname = cJSON_GetObjectItem(superQuery, "stblname");
if (stblname && stblname->type == cJSON_String
&& stblname->valuestring != NULL) {
- tstrncpy(g_queryInfo.superQueryInfo.sTblName, stblname->valuestring,
+ tstrncpy(g_queryInfo.superQueryInfo.stbName, stblname->valuestring,
TSDB_TABLE_NAME_LEN);
} else {
errorPrint("%s", "failed to read json, super table name input error\n");
@@ -5734,23 +6039,37 @@ static int prepareSampleData() {
static void postFreeResource() {
tmfclose(g_fpOfInsertResult);
+
for (int i = 0; i < g_Dbs.dbCount; i++) {
for (uint64_t j = 0; j < g_Dbs.db[i].superTblCount; j++) {
if (0 != g_Dbs.db[i].superTbls[j].colsOfCreateChildTable) {
- free(g_Dbs.db[i].superTbls[j].colsOfCreateChildTable);
+ tmfree(g_Dbs.db[i].superTbls[j].colsOfCreateChildTable);
g_Dbs.db[i].superTbls[j].colsOfCreateChildTable = NULL;
}
if (0 != g_Dbs.db[i].superTbls[j].sampleDataBuf) {
- free(g_Dbs.db[i].superTbls[j].sampleDataBuf);
+ tmfree(g_Dbs.db[i].superTbls[j].sampleDataBuf);
g_Dbs.db[i].superTbls[j].sampleDataBuf = NULL;
}
+#if STMT_BIND_PARAM_BATCH == 1
+ for (int c = 0;
+ c < g_Dbs.db[i].superTbls[j].columnCount; c ++) {
+
+ if (g_Dbs.db[i].superTbls[j].sampleBindBatchArray) {
+
+ tmfree((char *)((uintptr_t)*(uintptr_t*)(
+ g_Dbs.db[i].superTbls[j].sampleBindBatchArray
+ + sizeof(char*) * c)));
+ }
+ }
+ tmfree(g_Dbs.db[i].superTbls[j].sampleBindBatchArray);
+#endif
if (0 != g_Dbs.db[i].superTbls[j].tagDataBuf) {
- free(g_Dbs.db[i].superTbls[j].tagDataBuf);
+ tmfree(g_Dbs.db[i].superTbls[j].tagDataBuf);
g_Dbs.db[i].superTbls[j].tagDataBuf = NULL;
}
if (0 != g_Dbs.db[i].superTbls[j].childTblName) {
- free(g_Dbs.db[i].superTbls[j].childTblName);
+ tmfree(g_Dbs.db[i].superTbls[j].childTblName);
g_Dbs.db[i].superTbls[j].childTblName = NULL;
}
}
@@ -5766,13 +6085,26 @@ static void postFreeResource() {
tmfree(g_rand_current_buff);
tmfree(g_rand_phase_buff);
+ tmfree(g_sampleDataBuf);
+
+#if STMT_BIND_PARAM_BATCH == 1
+ for (int l = 0;
+ l < g_args.columnCount; l ++) {
+ if (g_sampleBindBatchArray) {
+ tmfree((char *)((uintptr_t)*(uintptr_t*)(
+ g_sampleBindBatchArray
+ + sizeof(char*) * l)));
+ }
+ }
+ tmfree(g_sampleBindBatchArray);
+#endif
}
static int getRowDataFromSample(
char* dataBuf, int64_t maxLen, int64_t timestamp,
SSuperTable* stbInfo, int64_t* sampleUsePos)
{
- if ((*sampleUsePos) == MAX_SAMPLES_ONCE_FROM_FILE) {
+ if ((*sampleUsePos) == MAX_SAMPLES) {
*sampleUsePos = 0;
}
@@ -5803,13 +6135,14 @@ static int64_t generateStbRowData(
int tmpLen;
dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
- "(%" PRId64 ",", timestamp);
+ "(%" PRId64 "", timestamp);
for (int i = 0; i < stbInfo->columnCount; i++) {
- if ((0 == strncasecmp(stbInfo->columns[i].dataType,
- "BINARY", 6))
- || (0 == strncasecmp(stbInfo->columns[i].dataType,
- "NCHAR", 5))) {
+ tstrncpy(pstr + dataLen, ",", 2);
+ dataLen += 1;
+
+ if ((stbInfo->columns[i].data_type == TSDB_DATA_TYPE_BINARY)
+ || (stbInfo->columns[i].data_type == TSDB_DATA_TYPE_NCHAR)) {
if (stbInfo->columns[i].dataLen > TSDB_MAX_BINARY_LEN) {
errorPrint2("binary or nchar length overflow, max size:%u\n",
(uint32_t)TSDB_MAX_BINARY_LEN);
@@ -5827,80 +6160,91 @@ static int64_t generateStbRowData(
return -1;
}
rand_string(buf, stbInfo->columns[i].dataLen);
- dataLen += snprintf(pstr + dataLen, maxLen - dataLen, "\'%s\',", buf);
+ dataLen += snprintf(pstr + dataLen, maxLen - dataLen, "\'%s\'", buf);
tmfree(buf);
} else {
- char *tmp;
+ char *tmp = NULL;
+ switch(stbInfo->columns[i].data_type) {
+ case TSDB_DATA_TYPE_INT:
+ if ((g_args.demo_mode) && (i == 1)) {
+ tmp = demo_voltage_int_str();
+ } else {
+ tmp = rand_int_str();
+ }
+ tmpLen = strlen(tmp);
+ tstrncpy(pstr + dataLen, tmp, min(tmpLen + 1, INT_BUFF_LEN));
+ break;
- if (0 == strncasecmp(stbInfo->columns[i].dataType,
- "INT", 3)) {
- if ((g_args.demo_mode) && (i == 1)) {
- tmp = demo_voltage_int_str();
- } else {
- tmp = rand_int_str();
- }
- tmpLen = strlen(tmp);
- tstrncpy(pstr + dataLen, tmp, min(tmpLen + 1, INT_BUFF_LEN));
- } else if (0 == strncasecmp(stbInfo->columns[i].dataType,
- "BIGINT", 6)) {
- tmp = rand_bigint_str();
- tstrncpy(pstr + dataLen, tmp, BIGINT_BUFF_LEN);
- } else if (0 == strncasecmp(stbInfo->columns[i].dataType,
- "FLOAT", 5)) {
- if (g_args.demo_mode) {
- if (i == 0) {
- tmp = demo_current_float_str();
+ case TSDB_DATA_TYPE_BIGINT:
+ tmp = rand_bigint_str();
+ tstrncpy(pstr + dataLen, tmp, BIGINT_BUFF_LEN);
+ break;
+
+ case TSDB_DATA_TYPE_FLOAT:
+ if (g_args.demo_mode) {
+ if (i == 0) {
+ tmp = demo_current_float_str();
+ } else {
+ tmp = demo_phase_float_str();
+ }
} else {
- tmp = demo_phase_float_str();
+ tmp = rand_float_str();
}
- } else {
- tmp = rand_float_str();
- }
- tmpLen = strlen(tmp);
- tstrncpy(pstr + dataLen, tmp, min(tmpLen +1, FLOAT_BUFF_LEN));
- } else if (0 == strncasecmp(stbInfo->columns[i].dataType,
- "DOUBLE", 6)) {
- tmp = rand_double_str();
- tmpLen = strlen(tmp);
- tstrncpy(pstr + dataLen, tmp, min(tmpLen +1, DOUBLE_BUFF_LEN));
- } else if (0 == strncasecmp(stbInfo->columns[i].dataType,
- "SMALLINT", 8)) {
- tmp = rand_smallint_str();
- tmpLen = strlen(tmp);
- tstrncpy(pstr + dataLen, tmp,
- min(tmpLen + 1, SMALLINT_BUFF_LEN));
- } else if (0 == strncasecmp(stbInfo->columns[i].dataType,
- "TINYINT", 7)) {
- tmp = rand_tinyint_str();
- tmpLen = strlen(tmp);
- tstrncpy(pstr + dataLen, tmp, min(tmpLen +1, TINYINT_BUFF_LEN));
- } else if (0 == strncasecmp(stbInfo->columns[i].dataType,
- "BOOL", 4)) {
- tmp = rand_bool_str();
- tmpLen = strlen(tmp);
- tstrncpy(pstr + dataLen, tmp, min(tmpLen +1, BOOL_BUFF_LEN));
- } else if (0 == strncasecmp(stbInfo->columns[i].dataType,
- "TIMESTAMP", 9)) {
- tmp = rand_bigint_str();
- tmpLen = strlen(tmp);
- tstrncpy(pstr + dataLen, tmp, min(tmpLen +1, BIGINT_BUFF_LEN));
- } else {
- errorPrint2("Not support data type: %s\n",
- stbInfo->columns[i].dataType);
- return -1;
+ tmpLen = strlen(tmp);
+ tstrncpy(pstr + dataLen, tmp, min(tmpLen +1, FLOAT_BUFF_LEN));
+ break;
+
+ case TSDB_DATA_TYPE_DOUBLE:
+ tmp = rand_double_str();
+ tmpLen = strlen(tmp);
+ tstrncpy(pstr + dataLen, tmp, min(tmpLen +1, DOUBLE_BUFF_LEN));
+ break;
+
+ case TSDB_DATA_TYPE_SMALLINT:
+ tmp = rand_smallint_str();
+ tmpLen = strlen(tmp);
+ tstrncpy(pstr + dataLen, tmp,
+ min(tmpLen + 1, SMALLINT_BUFF_LEN));
+ break;
+
+ case TSDB_DATA_TYPE_TINYINT:
+ tmp = rand_tinyint_str();
+ tmpLen = strlen(tmp);
+ tstrncpy(pstr + dataLen, tmp, min(tmpLen +1, TINYINT_BUFF_LEN));
+ break;
+
+ case TSDB_DATA_TYPE_BOOL:
+ tmp = rand_bool_str();
+ tmpLen = strlen(tmp);
+ tstrncpy(pstr + dataLen, tmp, min(tmpLen +1, BOOL_BUFF_LEN));
+ break;
+
+ case TSDB_DATA_TYPE_TIMESTAMP:
+ tmp = rand_bigint_str();
+ tmpLen = strlen(tmp);
+ tstrncpy(pstr + dataLen, tmp, min(tmpLen +1, BIGINT_BUFF_LEN));
+ break;
+
+ case TSDB_DATA_TYPE_NULL:
+ break;
+
+ default:
+ errorPrint2("Not support data type: %s\n",
+ stbInfo->columns[i].dataType);
+ exit(EXIT_FAILURE);
}
- dataLen += strlen(tmp);
- tstrncpy(pstr + dataLen, ",", 2);
- dataLen += 1;
+ if (tmp) {
+ dataLen += strlen(tmp);
+ }
}
if (dataLen > (remainderBufLen - (128)))
return 0;
}
- tstrncpy(pstr + dataLen - 1, ")", 2);
+ tstrncpy(pstr + dataLen, ")", 2);
verbosePrint("%s() LN%d, dataLen:%"PRId64"\n", __func__, __LINE__, dataLen);
verbosePrint("%s() LN%d, recBuf:\n\t%s\n", __func__, __LINE__, recBuf);
@@ -5908,53 +6252,83 @@ static int64_t generateStbRowData(
return strlen(recBuf);
}
-static int64_t generateData(char *recBuf, char **data_type,
+static int64_t generateData(char *recBuf, char *data_type,
int64_t timestamp, int lenOfBinary) {
memset(recBuf, 0, MAX_DATA_SIZE);
char *pstr = recBuf;
pstr += sprintf(pstr, "(%"PRId64"", timestamp);
- int columnCount = g_args.num_of_CPR;
+ int columnCount = g_args.columnCount;
+ bool b;
+ char *s;
for (int i = 0; i < columnCount; i++) {
- if (strcasecmp(data_type[i % columnCount], "TINYINT") == 0) {
- pstr += sprintf(pstr, ",%d", rand_tinyint() );
- } else if (strcasecmp(data_type[i % columnCount], "SMALLINT") == 0) {
- pstr += sprintf(pstr, ",%d", rand_smallint());
- } else if (strcasecmp(data_type[i % columnCount], "INT") == 0) {
- pstr += sprintf(pstr, ",%d", rand_int());
- } else if (strcasecmp(data_type[i % columnCount], "BIGINT") == 0) {
- pstr += sprintf(pstr, ",%"PRId64"", rand_bigint());
- } else if (strcasecmp(data_type[i % columnCount], "TIMESTAMP") == 0) {
- pstr += sprintf(pstr, ",%"PRId64"", rand_bigint());
- } else if (strcasecmp(data_type[i % columnCount], "FLOAT") == 0) {
- pstr += sprintf(pstr, ",%10.4f", rand_float());
- } else if (strcasecmp(data_type[i % columnCount], "DOUBLE") == 0) {
- double t = rand_double();
- pstr += sprintf(pstr, ",%20.8f", t);
- } else if (strcasecmp(data_type[i % columnCount], "BOOL") == 0) {
- bool b = rand_bool() & 1;
- pstr += sprintf(pstr, ",%s", b ? "true" : "false");
- } else if (strcasecmp(data_type[i % columnCount], "BINARY") == 0) {
- char *s = malloc(lenOfBinary + 1);
- if (s == NULL) {
- errorPrint2("%s() LN%d, memory allocation %d bytes failed\n",
- __func__, __LINE__, lenOfBinary + 1);
- exit(EXIT_FAILURE);
- }
- rand_string(s, lenOfBinary);
- pstr += sprintf(pstr, ",\"%s\"", s);
- free(s);
- } else if (strcasecmp(data_type[i % columnCount], "NCHAR") == 0) {
- char *s = malloc(lenOfBinary + 1);
- if (s == NULL) {
- errorPrint2("%s() LN%d, memory allocation %d bytes failed\n",
- __func__, __LINE__, lenOfBinary + 1);
+ switch (data_type[i]) {
+ case TSDB_DATA_TYPE_TINYINT:
+ pstr += sprintf(pstr, ",%d", rand_tinyint() );
+ break;
+
+ case TSDB_DATA_TYPE_SMALLINT:
+ pstr += sprintf(pstr, ",%d", rand_smallint());
+ break;
+
+ case TSDB_DATA_TYPE_INT:
+ pstr += sprintf(pstr, ",%d", rand_int());
+ break;
+
+ case TSDB_DATA_TYPE_BIGINT:
+ pstr += sprintf(pstr, ",%"PRId64"", rand_bigint());
+ break;
+
+ case TSDB_DATA_TYPE_TIMESTAMP:
+ pstr += sprintf(pstr, ",%"PRId64"", rand_bigint());
+ break;
+
+ case TSDB_DATA_TYPE_FLOAT:
+ pstr += sprintf(pstr, ",%10.4f", rand_float());
+ break;
+
+ case TSDB_DATA_TYPE_DOUBLE:
+ pstr += sprintf(pstr, ",%20.8f", rand_double());
+ break;
+
+ case TSDB_DATA_TYPE_BOOL:
+ b = rand_bool() & 1;
+ pstr += sprintf(pstr, ",%s", b ? "true" : "false");
+ break;
+
+ case TSDB_DATA_TYPE_BINARY:
+ s = malloc(lenOfBinary + 1);
+ if (s == NULL) {
+ errorPrint2("%s() LN%d, memory allocation %d bytes failed\n",
+ __func__, __LINE__, lenOfBinary + 1);
+ exit(EXIT_FAILURE);
+ }
+ rand_string(s, lenOfBinary);
+ pstr += sprintf(pstr, ",\"%s\"", s);
+ free(s);
+ break;
+
+ case TSDB_DATA_TYPE_NCHAR:
+ s = malloc(lenOfBinary + 1);
+ if (s == NULL) {
+ errorPrint2("%s() LN%d, memory allocation %d bytes failed\n",
+ __func__, __LINE__, lenOfBinary + 1);
+ exit(EXIT_FAILURE);
+ }
+ rand_string(s, lenOfBinary);
+ pstr += sprintf(pstr, ",\"%s\"", s);
+ free(s);
+ break;
+
+ case TSDB_DATA_TYPE_NULL:
+ break;
+
+ default:
+ errorPrint2("%s() LN%d, Unknown data type %d\n",
+ __func__, __LINE__,
+ data_type[i]);
exit(EXIT_FAILURE);
- }
- rand_string(s, lenOfBinary);
- pstr += sprintf(pstr, ",\"%s\"", s);
- free(s);
}
if (strlen(recBuf) > MAX_DATA_SIZE) {
@@ -5969,97 +6343,160 @@ static int64_t generateData(char *recBuf, char **data_type,
return (int32_t)strlen(recBuf);
}
-static int generateSampleMemoryFromRand(SSuperTable *stbInfo)
+static int generateSampleFromRand(
+ char *sampleDataBuf,
+ uint64_t lenOfOneRow,
+ int columnCount,
+ StrColumn *columns
+ )
{
char data[MAX_DATA_SIZE];
memset(data, 0, MAX_DATA_SIZE);
- char *buff = malloc(stbInfo->lenOfOneRow);
+ char *buff = malloc(lenOfOneRow);
if (NULL == buff) {
- errorPrint2("%s() LN%d, memory allocation %"PRId64" bytes failed\n",
- __func__, __LINE__, stbInfo->lenOfOneRow);
+ errorPrint2("%s() LN%d, memory allocation %"PRIu64" bytes failed\n",
+ __func__, __LINE__, lenOfOneRow);
exit(EXIT_FAILURE);
}
- for (int i=0; i < MAX_SAMPLES_ONCE_FROM_FILE; i++) {
+ for (int i=0; i < MAX_SAMPLES; i++) {
uint64_t pos = 0;
- memset(buff, 0, stbInfo->lenOfOneRow);
+ memset(buff, 0, lenOfOneRow);
- for (int c = 0; c < stbInfo->columnCount; c++) {
- char *tmp;
- if (0 == strncasecmp(stbInfo->columns[c].dataType,
- "BINARY", strlen("BINARY"))) {
- rand_string(data, stbInfo->columns[c].dataLen);
- pos += sprintf(buff + pos, "%s,", data);
- } else if (0 == strncasecmp(stbInfo->columns[c].dataType,
- "NCHAR", strlen("NCHAR"))) {
- rand_string(data, stbInfo->columns[c].dataLen);
- pos += sprintf(buff + pos, "%s,", data);
- } else if (0 == strncasecmp(stbInfo->columns[c].dataType,
- "INT", strlen("INT"))) {
- if ((g_args.demo_mode) && (c == 1)) {
- tmp = demo_voltage_int_str();
- } else {
- tmp = rand_int_str();
- }
- pos += sprintf(buff + pos, "%s,", tmp);
- } else if (0 == strncasecmp(stbInfo->columns[c].dataType,
- "BIGINT", strlen("BIGINT"))) {
- pos += sprintf(buff + pos, "%s,", rand_bigint_str());
- } else if (0 == strncasecmp(stbInfo->columns[c].dataType,
- "FLOAT", strlen("FLOAT"))) {
- if (g_args.demo_mode) {
- if (c == 0) {
- tmp = demo_current_float_str();
+ for (int c = 0; c < columnCount; c++) {
+ char *tmp = NULL;
+
+ uint32_t dataLen;
+ char data_type = (columns)?(columns[c].data_type):g_args.data_type[c];
+
+ switch(data_type) {
+ case TSDB_DATA_TYPE_BINARY:
+ dataLen = (columns)?columns[c].dataLen:g_args.binwidth;
+ rand_string(data, dataLen);
+ pos += sprintf(buff + pos, "%s,", data);
+ break;
+
+ case TSDB_DATA_TYPE_NCHAR:
+ dataLen = (columns)?columns[c].dataLen:g_args.binwidth;
+ rand_string(data, dataLen);
+ pos += sprintf(buff + pos, "%s,", data);
+ break;
+
+ case TSDB_DATA_TYPE_INT:
+ if ((g_args.demo_mode) && (c == 1)) {
+ tmp = demo_voltage_int_str();
} else {
- tmp = demo_phase_float_str();
+ tmp = rand_int_str();
}
- } else {
- tmp = rand_float_str();
- }
- pos += sprintf(buff + pos, "%s,", tmp);
- } else if (0 == strncasecmp(stbInfo->columns[c].dataType,
- "DOUBLE", strlen("DOUBLE"))) {
- pos += sprintf(buff + pos, "%s,", rand_double_str());
- } else if (0 == strncasecmp(stbInfo->columns[c].dataType,
- "SMALLINT", strlen("SMALLINT"))) {
- pos += sprintf(buff + pos, "%s,", rand_smallint_str());
- } else if (0 == strncasecmp(stbInfo->columns[c].dataType,
- "TINYINT", strlen("TINYINT"))) {
- pos += sprintf(buff + pos, "%s,", rand_tinyint_str());
- } else if (0 == strncasecmp(stbInfo->columns[c].dataType,
- "BOOL", strlen("BOOL"))) {
- pos += sprintf(buff + pos, "%s,", rand_bool_str());
- } else if (0 == strncasecmp(stbInfo->columns[c].dataType,
- "TIMESTAMP", strlen("TIMESTAMP"))) {
- pos += sprintf(buff + pos, "%s,", rand_bigint_str());
+ pos += sprintf(buff + pos, "%s,", tmp);
+ break;
+
+ case TSDB_DATA_TYPE_BIGINT:
+ pos += sprintf(buff + pos, "%s,", rand_bigint_str());
+ break;
+
+ case TSDB_DATA_TYPE_FLOAT:
+ if (g_args.demo_mode) {
+ if (c == 0) {
+ tmp = demo_current_float_str();
+ } else {
+ tmp = demo_phase_float_str();
+ }
+ } else {
+ tmp = rand_float_str();
+ }
+ pos += sprintf(buff + pos, "%s,", tmp);
+ break;
+
+ case TSDB_DATA_TYPE_DOUBLE:
+ pos += sprintf(buff + pos, "%s,", rand_double_str());
+ break;
+
+ case TSDB_DATA_TYPE_SMALLINT:
+ pos += sprintf(buff + pos, "%s,", rand_smallint_str());
+ break;
+
+ case TSDB_DATA_TYPE_TINYINT:
+ pos += sprintf(buff + pos, "%s,", rand_tinyint_str());
+ break;
+
+ case TSDB_DATA_TYPE_BOOL:
+ pos += sprintf(buff + pos, "%s,", rand_bool_str());
+ break;
+
+ case TSDB_DATA_TYPE_TIMESTAMP:
+ pos += sprintf(buff + pos, "%s,", rand_bigint_str());
+ break;
+
+ case TSDB_DATA_TYPE_NULL:
+ break;
+
+ default:
+ errorPrint2("%s() LN%d, Unknown data type %s\n",
+ __func__, __LINE__,
+ (columns)?(columns[c].dataType):g_args.dataType[c]);
+ exit(EXIT_FAILURE);
}
}
+
*(buff + pos - 1) = 0;
- memcpy(stbInfo->sampleDataBuf + i * stbInfo->lenOfOneRow, buff, pos);
+ memcpy(sampleDataBuf + i * lenOfOneRow, buff, pos);
}
free(buff);
return 0;
}
-static int prepareSampleDataForSTable(SSuperTable *stbInfo) {
+static int generateSampleFromRandForNtb()
+{
+ return generateSampleFromRand(
+ g_sampleDataBuf,
+ g_args.lenOfOneRow,
+ g_args.columnCount,
+ NULL);
+}
+
+static int generateSampleFromRandForStb(SSuperTable *stbInfo)
+{
+ return generateSampleFromRand(
+ stbInfo->sampleDataBuf,
+ stbInfo->lenOfOneRow,
+ stbInfo->columnCount,
+ stbInfo->columns);
+}
+
+static int prepareSampleForNtb() {
+ g_sampleDataBuf = calloc(g_args.lenOfOneRow * MAX_SAMPLES, 1);
+ if (NULL == g_sampleDataBuf) {
+ errorPrint2("%s() LN%d, Failed to calloc %"PRIu64" Bytes, reason:%s\n",
+ __func__, __LINE__,
+ g_args.lenOfOneRow * MAX_SAMPLES,
+ strerror(errno));
+ return -1;
+ }
+
+ return generateSampleFromRandForNtb();
+}
+
+static int prepareSampleForStb(SSuperTable *stbInfo) {
stbInfo->sampleDataBuf = calloc(
- stbInfo->lenOfOneRow * MAX_SAMPLES_ONCE_FROM_FILE, 1);
+ stbInfo->lenOfOneRow * MAX_SAMPLES, 1);
if (NULL == stbInfo->sampleDataBuf) {
errorPrint2("%s() LN%d, Failed to calloc %"PRIu64" Bytes, reason:%s\n",
__func__, __LINE__,
- stbInfo->lenOfOneRow * MAX_SAMPLES_ONCE_FROM_FILE,
+ stbInfo->lenOfOneRow * MAX_SAMPLES,
strerror(errno));
return -1;
}
int ret;
- if (0 == strncasecmp(stbInfo->dataSource, "sample", strlen("sample")))
- ret = readSampleFromCsvFileToMem(stbInfo);
- else
- ret = generateSampleMemoryFromRand(stbInfo);
+ if (0 == strncasecmp(stbInfo->dataSource, "sample", strlen("sample"))) {
+ ret = generateSampleFromCsvForStb(stbInfo);
+ } else {
+ ret = generateSampleFromRandForStb(stbInfo);
+ }
if (0 != ret) {
errorPrint2("%s() LN%d, read sample from csv file failed.\n",
@@ -6184,7 +6621,7 @@ static int32_t generateDataTailWithoutStb(
int64_t retLen = 0;
- char **data_type = g_args.datatype;
+ char *data_type = g_args.data_type;
int lenOfBinary = g_args.binwidth;
if (g_args.disorderRatio) {
@@ -6370,7 +6807,7 @@ static int generateStbSQLHead(
dbName,
tableName,
dbName,
- stbInfo->sTblName,
+ stbInfo->stbName,
tagsValBuf);
tmfree(tagsValBuf);
} else if (TBL_ALREADY_EXISTS == stbInfo->childTblExists) {
@@ -6502,202 +6939,224 @@ static int64_t generateInterlaceDataWithoutStb(
static int32_t prepareStmtBindArrayByType(
TAOS_BIND *bind,
- char *dataType, int32_t dataLen,
+ char data_type, int32_t dataLen,
int32_t timePrec,
char *value)
{
- if (0 == strncasecmp(dataType,
- "BINARY", strlen("BINARY"))) {
- if (dataLen > TSDB_MAX_BINARY_LEN) {
- errorPrint2("binary length overflow, max size:%u\n",
- (uint32_t)TSDB_MAX_BINARY_LEN);
- return -1;
- }
- char *bind_binary;
+ int32_t *bind_int;
+ int64_t *bind_bigint;
+ float *bind_float;
+ double *bind_double;
+ int8_t *bind_bool;
+ int64_t *bind_ts2;
+ int16_t *bind_smallint;
+ int8_t *bind_tinyint;
+
+ switch(data_type) {
+ case TSDB_DATA_TYPE_BINARY:
+ if (dataLen > TSDB_MAX_BINARY_LEN) {
+ errorPrint2("binary length overflow, max size:%u\n",
+ (uint32_t)TSDB_MAX_BINARY_LEN);
+ return -1;
+ }
+ char *bind_binary;
- bind->buffer_type = TSDB_DATA_TYPE_BINARY;
- if (value) {
- bind_binary = calloc(1, strlen(value) + 1);
- strncpy(bind_binary, value, strlen(value));
- bind->buffer_length = strlen(bind_binary);
- } else {
- bind_binary = calloc(1, dataLen + 1);
- rand_string(bind_binary, dataLen);
- bind->buffer_length = dataLen;
- }
+ bind->buffer_type = TSDB_DATA_TYPE_BINARY;
+ if (value) {
+ bind_binary = calloc(1, strlen(value) + 1);
+ strncpy(bind_binary, value, strlen(value));
+ bind->buffer_length = strlen(bind_binary);
+ } else {
+ bind_binary = calloc(1, dataLen + 1);
+ rand_string(bind_binary, dataLen);
+ bind->buffer_length = dataLen;
+ }
- bind->length = &bind->buffer_length;
- bind->buffer = bind_binary;
- bind->is_null = NULL;
- } else if (0 == strncasecmp(dataType,
- "NCHAR", strlen("NCHAR"))) {
- if (dataLen > TSDB_MAX_BINARY_LEN) {
- errorPrint2("nchar length overflow, max size:%u\n",
- (uint32_t)TSDB_MAX_BINARY_LEN);
- return -1;
- }
- char *bind_nchar;
+ bind->length = &bind->buffer_length;
+ bind->buffer = bind_binary;
+ bind->is_null = NULL;
+ break;
- bind->buffer_type = TSDB_DATA_TYPE_NCHAR;
- if (value) {
- bind_nchar = calloc(1, strlen(value) + 1);
- strncpy(bind_nchar, value, strlen(value));
- } else {
- bind_nchar = calloc(1, dataLen + 1);
- rand_string(bind_nchar, dataLen);
- }
+ case TSDB_DATA_TYPE_NCHAR:
+ if (dataLen > TSDB_MAX_BINARY_LEN) {
+ errorPrint2("nchar length overflow, max size:%u\n",
+ (uint32_t)TSDB_MAX_BINARY_LEN);
+ return -1;
+ }
+ char *bind_nchar;
- bind->buffer_length = strlen(bind_nchar);
- bind->buffer = bind_nchar;
- bind->length = &bind->buffer_length;
- bind->is_null = NULL;
- } else if (0 == strncasecmp(dataType,
- "INT", strlen("INT"))) {
- int32_t *bind_int = malloc(sizeof(int32_t));
- assert(bind_int);
+ bind->buffer_type = TSDB_DATA_TYPE_NCHAR;
+ if (value) {
+ bind_nchar = calloc(1, strlen(value) + 1);
+ strncpy(bind_nchar, value, strlen(value));
+ } else {
+ bind_nchar = calloc(1, dataLen + 1);
+ rand_string(bind_nchar, dataLen);
+ }
- if (value) {
- *bind_int = atoi(value);
- } else {
- *bind_int = rand_int();
- }
- bind->buffer_type = TSDB_DATA_TYPE_INT;
- bind->buffer_length = sizeof(int32_t);
- bind->buffer = bind_int;
- bind->length = &bind->buffer_length;
- bind->is_null = NULL;
- } else if (0 == strncasecmp(dataType,
- "BIGINT", strlen("BIGINT"))) {
- int64_t *bind_bigint = malloc(sizeof(int64_t));
- assert(bind_bigint);
+ bind->buffer_length = strlen(bind_nchar);
+ bind->buffer = bind_nchar;
+ bind->length = &bind->buffer_length;
+ bind->is_null = NULL;
+ break;
- if (value) {
- *bind_bigint = atoll(value);
- } else {
- *bind_bigint = rand_bigint();
- }
- bind->buffer_type = TSDB_DATA_TYPE_BIGINT;
- bind->buffer_length = sizeof(int64_t);
- bind->buffer = bind_bigint;
- bind->length = &bind->buffer_length;
- bind->is_null = NULL;
- } else if (0 == strncasecmp(dataType,
- "FLOAT", strlen("FLOAT"))) {
- float *bind_float = malloc(sizeof(float));
- assert(bind_float);
+ case TSDB_DATA_TYPE_INT:
+ bind_int = malloc(sizeof(int32_t));
+ assert(bind_int);
- if (value) {
- *bind_float = (float)atof(value);
- } else {
- *bind_float = rand_float();
- }
- bind->buffer_type = TSDB_DATA_TYPE_FLOAT;
- bind->buffer_length = sizeof(float);
- bind->buffer = bind_float;
- bind->length = &bind->buffer_length;
- bind->is_null = NULL;
- } else if (0 == strncasecmp(dataType,
- "DOUBLE", strlen("DOUBLE"))) {
- double *bind_double = malloc(sizeof(double));
- assert(bind_double);
+ if (value) {
+ *bind_int = atoi(value);
+ } else {
+ *bind_int = rand_int();
+ }
+ bind->buffer_type = TSDB_DATA_TYPE_INT;
+ bind->buffer_length = sizeof(int32_t);
+ bind->buffer = bind_int;
+ bind->length = &bind->buffer_length;
+ bind->is_null = NULL;
+ break;
- if (value) {
- *bind_double = atof(value);
- } else {
- *bind_double = rand_double();
- }
- bind->buffer_type = TSDB_DATA_TYPE_DOUBLE;
- bind->buffer_length = sizeof(double);
- bind->buffer = bind_double;
- bind->length = &bind->buffer_length;
- bind->is_null = NULL;
- } else if (0 == strncasecmp(dataType,
- "SMALLINT", strlen("SMALLINT"))) {
- int16_t *bind_smallint = malloc(sizeof(int16_t));
- assert(bind_smallint);
+ case TSDB_DATA_TYPE_BIGINT:
+ bind_bigint = malloc(sizeof(int64_t));
+ assert(bind_bigint);
- if (value) {
- *bind_smallint = (int16_t)atoi(value);
- } else {
- *bind_smallint = rand_smallint();
- }
- bind->buffer_type = TSDB_DATA_TYPE_SMALLINT;
- bind->buffer_length = sizeof(int16_t);
- bind->buffer = bind_smallint;
- bind->length = &bind->buffer_length;
- bind->is_null = NULL;
- } else if (0 == strncasecmp(dataType,
- "TINYINT", strlen("TINYINT"))) {
- int8_t *bind_tinyint = malloc(sizeof(int8_t));
- assert(bind_tinyint);
+ if (value) {
+ *bind_bigint = atoll(value);
+ } else {
+ *bind_bigint = rand_bigint();
+ }
+ bind->buffer_type = TSDB_DATA_TYPE_BIGINT;
+ bind->buffer_length = sizeof(int64_t);
+ bind->buffer = bind_bigint;
+ bind->length = &bind->buffer_length;
+ bind->is_null = NULL;
+ break;
- if (value) {
- *bind_tinyint = (int8_t)atoi(value);
- } else {
- *bind_tinyint = rand_tinyint();
- }
- bind->buffer_type = TSDB_DATA_TYPE_TINYINT;
- bind->buffer_length = sizeof(int8_t);
- bind->buffer = bind_tinyint;
- bind->length = &bind->buffer_length;
- bind->is_null = NULL;
- } else if (0 == strncasecmp(dataType,
- "BOOL", strlen("BOOL"))) {
- int8_t *bind_bool = malloc(sizeof(int8_t));
- assert(bind_bool);
-
- if (value) {
- if (strncasecmp(value, "true", 4)) {
- *bind_bool = true;
+ case TSDB_DATA_TYPE_FLOAT:
+ bind_float = malloc(sizeof(float));
+ assert(bind_float);
+
+ if (value) {
+ *bind_float = (float)atof(value);
} else {
- *bind_bool = false;
+ *bind_float = rand_float();
}
- } else {
- *bind_bool = rand_bool();
- }
- bind->buffer_type = TSDB_DATA_TYPE_BOOL;
- bind->buffer_length = sizeof(int8_t);
- bind->buffer = bind_bool;
- bind->length = &bind->buffer_length;
- bind->is_null = NULL;
+ bind->buffer_type = TSDB_DATA_TYPE_FLOAT;
+ bind->buffer_length = sizeof(float);
+ bind->buffer = bind_float;
+ bind->length = &bind->buffer_length;
+ bind->is_null = NULL;
+ break;
+
+ case TSDB_DATA_TYPE_DOUBLE:
+ bind_double = malloc(sizeof(double));
+ assert(bind_double);
+
+ if (value) {
+ *bind_double = atof(value);
+ } else {
+ *bind_double = rand_double();
+ }
+ bind->buffer_type = TSDB_DATA_TYPE_DOUBLE;
+ bind->buffer_length = sizeof(double);
+ bind->buffer = bind_double;
+ bind->length = &bind->buffer_length;
+ bind->is_null = NULL;
+ break;
- } else if (0 == strncasecmp(dataType,
- "TIMESTAMP", strlen("TIMESTAMP"))) {
- int64_t *bind_ts2 = malloc(sizeof(int64_t));
- assert(bind_ts2);
-
- if (value) {
- if (strchr(value, ':') && strchr(value, '-')) {
- int i = 0;
- while(value[i] != '\0') {
- if (value[i] == '\"' || value[i] == '\'') {
- value[i] = ' ';
+ case TSDB_DATA_TYPE_SMALLINT:
+ bind_smallint = malloc(sizeof(int16_t));
+ assert(bind_smallint);
+
+ if (value) {
+ *bind_smallint = (int16_t)atoi(value);
+ } else {
+ *bind_smallint = rand_smallint();
+ }
+ bind->buffer_type = TSDB_DATA_TYPE_SMALLINT;
+ bind->buffer_length = sizeof(int16_t);
+ bind->buffer = bind_smallint;
+ bind->length = &bind->buffer_length;
+ bind->is_null = NULL;
+ break;
+
+ case TSDB_DATA_TYPE_TINYINT:
+ bind_tinyint = malloc(sizeof(int8_t));
+ assert(bind_tinyint);
+
+ if (value) {
+ *bind_tinyint = (int8_t)atoi(value);
+ } else {
+ *bind_tinyint = rand_tinyint();
+ }
+ bind->buffer_type = TSDB_DATA_TYPE_TINYINT;
+ bind->buffer_length = sizeof(int8_t);
+ bind->buffer = bind_tinyint;
+ bind->length = &bind->buffer_length;
+ bind->is_null = NULL;
+ break;
+
+ case TSDB_DATA_TYPE_BOOL:
+ bind_bool = malloc(sizeof(int8_t));
+ assert(bind_bool);
+
+ if (value) {
+ if (strncasecmp(value, "true", 4)) {
+ *bind_bool = true;
+ } else {
+ *bind_bool = false;
+ }
+ } else {
+ *bind_bool = rand_bool();
+ }
+ bind->buffer_type = TSDB_DATA_TYPE_BOOL;
+ bind->buffer_length = sizeof(int8_t);
+ bind->buffer = bind_bool;
+ bind->length = &bind->buffer_length;
+ bind->is_null = NULL;
+ break;
+
+ case TSDB_DATA_TYPE_TIMESTAMP:
+ bind_ts2 = malloc(sizeof(int64_t));
+ assert(bind_ts2);
+
+ if (value) {
+ if (strchr(value, ':') && strchr(value, '-')) {
+ int i = 0;
+ while(value[i] != '\0') {
+ if (value[i] == '\"' || value[i] == '\'') {
+ value[i] = ' ';
+ }
+ i++;
}
- i++;
- }
- int64_t tmpEpoch;
- if (TSDB_CODE_SUCCESS != taosParseTime(
- value, &tmpEpoch, strlen(value),
- timePrec, 0)) {
- free(bind_ts2);
- errorPrint2("Input %s, time format error!\n", value);
- return -1;
+ int64_t tmpEpoch;
+ if (TSDB_CODE_SUCCESS != taosParseTime(
+ value, &tmpEpoch, strlen(value),
+ timePrec, 0)) {
+ free(bind_ts2);
+ errorPrint2("Input %s, time format error!\n", value);
+ return -1;
+ }
+ *bind_ts2 = tmpEpoch;
+ } else {
+ *bind_ts2 = atoll(value);
}
- *bind_ts2 = tmpEpoch;
} else {
- *bind_ts2 = atoll(value);
+ *bind_ts2 = rand_bigint();
}
- } else {
- *bind_ts2 = rand_bigint();
- }
- bind->buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
- bind->buffer_length = sizeof(int64_t);
- bind->buffer = bind_ts2;
- bind->length = &bind->buffer_length;
- bind->is_null = NULL;
- } else {
- errorPrint2("Not support data type: %s\n", dataType);
- return -1;
+ bind->buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
+ bind->buffer_length = sizeof(int64_t);
+ bind->buffer = bind_ts2;
+ bind->length = &bind->buffer_length;
+ bind->is_null = NULL;
+ break;
+
+ case TSDB_DATA_TYPE_NULL:
+ break;
+
+ default:
+ errorPrint2("Not support data type: %d\n", data_type);
+ exit(EXIT_FAILURE);
}
return 0;
@@ -6705,209 +7164,230 @@ static int32_t prepareStmtBindArrayByType(
static int32_t prepareStmtBindArrayByTypeForRand(
TAOS_BIND *bind,
- char *dataType, int32_t dataLen,
+ char data_type, int32_t dataLen,
int32_t timePrec,
char **ptr,
char *value)
{
- if (0 == strncasecmp(dataType,
- "BINARY", strlen("BINARY"))) {
- if (dataLen > TSDB_MAX_BINARY_LEN) {
- errorPrint2("binary length overflow, max size:%u\n",
- (uint32_t)TSDB_MAX_BINARY_LEN);
- return -1;
- }
- char *bind_binary = (char *)*ptr;
+ int32_t *bind_int;
+ int64_t *bind_bigint;
+ float *bind_float;
+ double *bind_double;
+ int16_t *bind_smallint;
+ int8_t *bind_tinyint;
+ int8_t *bind_bool;
+ int64_t *bind_ts2;
+
+ switch(data_type) {
+ case TSDB_DATA_TYPE_BINARY:
- bind->buffer_type = TSDB_DATA_TYPE_BINARY;
- if (value) {
- strncpy(bind_binary, value, strlen(value));
- bind->buffer_length = strlen(bind_binary);
- } else {
- rand_string(bind_binary, dataLen);
- bind->buffer_length = dataLen;
- }
+ if (dataLen > TSDB_MAX_BINARY_LEN) {
+ errorPrint2("binary length overflow, max size:%u\n",
+ (uint32_t)TSDB_MAX_BINARY_LEN);
+ return -1;
+ }
+ char *bind_binary = (char *)*ptr;
- bind->length = &bind->buffer_length;
- bind->buffer = bind_binary;
- bind->is_null = NULL;
+ bind->buffer_type = TSDB_DATA_TYPE_BINARY;
+ if (value) {
+ strncpy(bind_binary, value, strlen(value));
+ bind->buffer_length = strlen(bind_binary);
+ } else {
+ rand_string(bind_binary, dataLen);
+ bind->buffer_length = dataLen;
+ }
- *ptr += bind->buffer_length;
- } else if (0 == strncasecmp(dataType,
- "NCHAR", strlen("NCHAR"))) {
- if (dataLen > TSDB_MAX_BINARY_LEN) {
- errorPrint2("nchar length overflow, max size: %u\n",
- (uint32_t)TSDB_MAX_BINARY_LEN);
- return -1;
- }
- char *bind_nchar = (char *)*ptr;
+ bind->length = &bind->buffer_length;
+ bind->buffer = bind_binary;
+ bind->is_null = NULL;
- bind->buffer_type = TSDB_DATA_TYPE_NCHAR;
- if (value) {
- strncpy(bind_nchar, value, strlen(value));
- } else {
- rand_string(bind_nchar, dataLen);
- }
+ *ptr += bind->buffer_length;
+ break;
- bind->buffer_length = strlen(bind_nchar);
- bind->buffer = bind_nchar;
- bind->length = &bind->buffer_length;
- bind->is_null = NULL;
+ case TSDB_DATA_TYPE_NCHAR:
+ if (dataLen > TSDB_MAX_BINARY_LEN) {
+ errorPrint2("nchar length overflow, max size: %u\n",
+ (uint32_t)TSDB_MAX_BINARY_LEN);
+ return -1;
+ }
+ char *bind_nchar = (char *)*ptr;
- *ptr += bind->buffer_length;
- } else if (0 == strncasecmp(dataType,
- "INT", strlen("INT"))) {
- int32_t *bind_int = (int32_t *)*ptr;
+ bind->buffer_type = TSDB_DATA_TYPE_NCHAR;
+ if (value) {
+ strncpy(bind_nchar, value, strlen(value));
+ } else {
+ rand_string(bind_nchar, dataLen);
+ }
- if (value) {
- *bind_int = atoi(value);
- } else {
- *bind_int = rand_int();
- }
- bind->buffer_type = TSDB_DATA_TYPE_INT;
- bind->buffer_length = sizeof(int32_t);
- bind->buffer = bind_int;
- bind->length = &bind->buffer_length;
- bind->is_null = NULL;
+ bind->buffer_length = strlen(bind_nchar);
+ bind->buffer = bind_nchar;
+ bind->length = &bind->buffer_length;
+ bind->is_null = NULL;
- *ptr += bind->buffer_length;
- } else if (0 == strncasecmp(dataType,
- "BIGINT", strlen("BIGINT"))) {
- int64_t *bind_bigint = (int64_t *)*ptr;
+ *ptr += bind->buffer_length;
+ break;
- if (value) {
- *bind_bigint = atoll(value);
- } else {
- *bind_bigint = rand_bigint();
- }
- bind->buffer_type = TSDB_DATA_TYPE_BIGINT;
- bind->buffer_length = sizeof(int64_t);
- bind->buffer = bind_bigint;
- bind->length = &bind->buffer_length;
- bind->is_null = NULL;
+ case TSDB_DATA_TYPE_INT:
+ bind_int = (int32_t *)*ptr;
- *ptr += bind->buffer_length;
- } else if (0 == strncasecmp(dataType,
- "FLOAT", strlen("FLOAT"))) {
- float *bind_float = (float *)*ptr;
+ if (value) {
+ *bind_int = atoi(value);
+ } else {
+ *bind_int = rand_int();
+ }
+ bind->buffer_type = TSDB_DATA_TYPE_INT;
+ bind->buffer_length = sizeof(int32_t);
+ bind->buffer = bind_int;
+ bind->length = &bind->buffer_length;
+ bind->is_null = NULL;
- if (value) {
- *bind_float = (float)atof(value);
- } else {
- *bind_float = rand_float();
- }
- bind->buffer_type = TSDB_DATA_TYPE_FLOAT;
- bind->buffer_length = sizeof(float);
- bind->buffer = bind_float;
- bind->length = &bind->buffer_length;
- bind->is_null = NULL;
+ *ptr += bind->buffer_length;
+ break;
- *ptr += bind->buffer_length;
- } else if (0 == strncasecmp(dataType,
- "DOUBLE", strlen("DOUBLE"))) {
- double *bind_double = (double *)*ptr;
+ case TSDB_DATA_TYPE_BIGINT:
+ bind_bigint = (int64_t *)*ptr;
- if (value) {
- *bind_double = atof(value);
- } else {
- *bind_double = rand_double();
- }
- bind->buffer_type = TSDB_DATA_TYPE_DOUBLE;
- bind->buffer_length = sizeof(double);
- bind->buffer = bind_double;
- bind->length = &bind->buffer_length;
- bind->is_null = NULL;
+ if (value) {
+ *bind_bigint = atoll(value);
+ } else {
+ *bind_bigint = rand_bigint();
+ }
+ bind->buffer_type = TSDB_DATA_TYPE_BIGINT;
+ bind->buffer_length = sizeof(int64_t);
+ bind->buffer = bind_bigint;
+ bind->length = &bind->buffer_length;
+ bind->is_null = NULL;
- *ptr += bind->buffer_length;
- } else if (0 == strncasecmp(dataType,
- "SMALLINT", strlen("SMALLINT"))) {
- int16_t *bind_smallint = (int16_t *)*ptr;
+ *ptr += bind->buffer_length;
+ break;
- if (value) {
- *bind_smallint = (int16_t)atoi(value);
- } else {
- *bind_smallint = rand_smallint();
- }
- bind->buffer_type = TSDB_DATA_TYPE_SMALLINT;
- bind->buffer_length = sizeof(int16_t);
- bind->buffer = bind_smallint;
- bind->length = &bind->buffer_length;
- bind->is_null = NULL;
+ case TSDB_DATA_TYPE_FLOAT:
+ bind_float = (float *)*ptr;
- *ptr += bind->buffer_length;
- } else if (0 == strncasecmp(dataType,
- "TINYINT", strlen("TINYINT"))) {
- int8_t *bind_tinyint = (int8_t *)*ptr;
+ if (value) {
+ *bind_float = (float)atof(value);
+ } else {
+ *bind_float = rand_float();
+ }
+ bind->buffer_type = TSDB_DATA_TYPE_FLOAT;
+ bind->buffer_length = sizeof(float);
+ bind->buffer = bind_float;
+ bind->length = &bind->buffer_length;
+ bind->is_null = NULL;
- if (value) {
- *bind_tinyint = (int8_t)atoi(value);
- } else {
- *bind_tinyint = rand_tinyint();
- }
- bind->buffer_type = TSDB_DATA_TYPE_TINYINT;
- bind->buffer_length = sizeof(int8_t);
- bind->buffer = bind_tinyint;
- bind->length = &bind->buffer_length;
- bind->is_null = NULL;
+ *ptr += bind->buffer_length;
+ break;
- *ptr += bind->buffer_length;
- } else if (0 == strncasecmp(dataType,
- "BOOL", strlen("BOOL"))) {
- int8_t *bind_bool = (int8_t *)*ptr;
+ case TSDB_DATA_TYPE_DOUBLE:
+ bind_double = (double *)*ptr;
- if (value) {
- if (strncasecmp(value, "true", 4)) {
- *bind_bool = true;
+ if (value) {
+ *bind_double = atof(value);
} else {
- *bind_bool = false;
+ *bind_double = rand_double();
}
- } else {
- *bind_bool = rand_bool();
- }
- bind->buffer_type = TSDB_DATA_TYPE_BOOL;
- bind->buffer_length = sizeof(int8_t);
- bind->buffer = bind_bool;
- bind->length = &bind->buffer_length;
- bind->is_null = NULL;
+ bind->buffer_type = TSDB_DATA_TYPE_DOUBLE;
+ bind->buffer_length = sizeof(double);
+ bind->buffer = bind_double;
+ bind->length = &bind->buffer_length;
+ bind->is_null = NULL;
- *ptr += bind->buffer_length;
- } else if (0 == strncasecmp(dataType,
- "TIMESTAMP", strlen("TIMESTAMP"))) {
- int64_t *bind_ts2 = (int64_t *)*ptr;
-
- if (value) {
- if (strchr(value, ':') && strchr(value, '-')) {
- int i = 0;
- while(value[i] != '\0') {
- if (value[i] == '\"' || value[i] == '\'') {
- value[i] = ' ';
- }
- i++;
+ *ptr += bind->buffer_length;
+ break;
+
+ case TSDB_DATA_TYPE_SMALLINT:
+ bind_smallint = (int16_t *)*ptr;
+
+ if (value) {
+ *bind_smallint = (int16_t)atoi(value);
+ } else {
+ *bind_smallint = rand_smallint();
+ }
+ bind->buffer_type = TSDB_DATA_TYPE_SMALLINT;
+ bind->buffer_length = sizeof(int16_t);
+ bind->buffer = bind_smallint;
+ bind->length = &bind->buffer_length;
+ bind->is_null = NULL;
+
+ *ptr += bind->buffer_length;
+ break;
+
+ case TSDB_DATA_TYPE_TINYINT:
+ bind_tinyint = (int8_t *)*ptr;
+
+ if (value) {
+ *bind_tinyint = (int8_t)atoi(value);
+ } else {
+ *bind_tinyint = rand_tinyint();
+ }
+ bind->buffer_type = TSDB_DATA_TYPE_TINYINT;
+ bind->buffer_length = sizeof(int8_t);
+ bind->buffer = bind_tinyint;
+ bind->length = &bind->buffer_length;
+ bind->is_null = NULL;
+
+ *ptr += bind->buffer_length;
+ break;
+
+ case TSDB_DATA_TYPE_BOOL:
+ bind_bool = (int8_t *)*ptr;
+
+ if (value) {
+ if (strncasecmp(value, "true", 4)) {
+ *bind_bool = true;
+ } else {
+ *bind_bool = false;
}
- int64_t tmpEpoch;
- if (TSDB_CODE_SUCCESS != taosParseTime(
- value, &tmpEpoch, strlen(value),
- timePrec, 0)) {
- errorPrint2("Input %s, time format error!\n", value);
- return -1;
+ } else {
+ *bind_bool = rand_bool();
+ }
+ bind->buffer_type = TSDB_DATA_TYPE_BOOL;
+ bind->buffer_length = sizeof(int8_t);
+ bind->buffer = bind_bool;
+ bind->length = &bind->buffer_length;
+ bind->is_null = NULL;
+
+ *ptr += bind->buffer_length;
+ break;
+
+ case TSDB_DATA_TYPE_TIMESTAMP:
+ bind_ts2 = (int64_t *)*ptr;
+
+ if (value) {
+ if (strchr(value, ':') && strchr(value, '-')) {
+ int i = 0;
+ while(value[i] != '\0') {
+ if (value[i] == '\"' || value[i] == '\'') {
+ value[i] = ' ';
+ }
+ i++;
+ }
+ int64_t tmpEpoch;
+ if (TSDB_CODE_SUCCESS != taosParseTime(
+ value, &tmpEpoch, strlen(value),
+ timePrec, 0)) {
+ errorPrint2("Input %s, time format error!\n", value);
+ return -1;
+ }
+ *bind_ts2 = tmpEpoch;
+ } else {
+ *bind_ts2 = atoll(value);
}
- *bind_ts2 = tmpEpoch;
} else {
- *bind_ts2 = atoll(value);
+ *bind_ts2 = rand_bigint();
}
- } else {
- *bind_ts2 = rand_bigint();
- }
- bind->buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
- bind->buffer_length = sizeof(int64_t);
- bind->buffer = bind_ts2;
- bind->length = &bind->buffer_length;
- bind->is_null = NULL;
+ bind->buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
+ bind->buffer_length = sizeof(int64_t);
+ bind->buffer = bind_ts2;
+ bind->length = &bind->buffer_length;
+ bind->is_null = NULL;
- *ptr += bind->buffer_length;
- } else {
- errorPrint2("No support data type: %s\n", dataType);
- return -1;
+ *ptr += bind->buffer_length;
+ break;
+
+ default:
+ errorPrint2("No support data type: %d\n", data_type);
+ return -1;
}
return 0;
@@ -6929,12 +7409,12 @@ static int32_t prepareStmtWithoutStb(
return ret;
}
- char **data_type = g_args.datatype;
+ char *data_type = g_args.data_type;
- char *bindArray = malloc(sizeof(TAOS_BIND) * (g_args.num_of_CPR + 1));
+ char *bindArray = malloc(sizeof(TAOS_BIND) * (g_args.columnCount + 1));
if (bindArray == NULL) {
errorPrint2("Failed to allocate %d bind params\n",
- (g_args.num_of_CPR + 1));
+ (g_args.columnCount + 1));
return -1;
}
@@ -6961,7 +7441,7 @@ static int32_t prepareStmtWithoutStb(
bind->length = &bind->buffer_length;
bind->is_null = NULL;
- for (int i = 0; i < g_args.num_of_CPR; i ++) {
+ for (int i = 0; i < g_args.columnCount; i ++) {
bind = (TAOS_BIND *)((char *)bindArray
+ (sizeof(TAOS_BIND) * (i + 1)));
if ( -1 == prepareStmtBindArrayByType(
@@ -7001,29 +7481,20 @@ static int32_t prepareStbStmtBindTag(
char *tagsVal,
int32_t timePrec)
{
- char *bindBuffer = calloc(1, DOUBLE_BUFF_LEN); // g_args.binwidth);
- if (bindBuffer == NULL) {
- errorPrint2("%s() LN%d, Failed to allocate %d bind buffer\n",
- __func__, __LINE__, DOUBLE_BUFF_LEN);
- return -1;
- }
-
TAOS_BIND *tag;
for (int t = 0; t < stbInfo->tagCount; t ++) {
tag = (TAOS_BIND *)((char *)bindArray + (sizeof(TAOS_BIND) * t));
if ( -1 == prepareStmtBindArrayByType(
tag,
- stbInfo->tags[t].dataType,
+ stbInfo->tags[t].data_type,
stbInfo->tags[t].dataLen,
timePrec,
NULL)) {
- free(bindBuffer);
return -1;
}
}
- free(bindBuffer);
return 0;
}
@@ -7033,13 +7504,6 @@ static int32_t prepareStbStmtBindRand(
int64_t startTime, int32_t recSeq,
int32_t timePrec)
{
- char *bindBuffer = calloc(1, DOUBLE_BUFF_LEN); // g_args.binwidth);
- if (bindBuffer == NULL) {
- errorPrint2("%s() LN%d, Failed to allocate %d bind buffer\n",
- __func__, __LINE__, DOUBLE_BUFF_LEN);
- return -1;
- }
-
char data[MAX_DATA_SIZE];
memset(data, 0, MAX_DATA_SIZE);
char *ptr = data;
@@ -7069,51 +7533,15 @@ static int32_t prepareStbStmtBindRand(
ptr += bind->buffer_length;
} else if ( -1 == prepareStmtBindArrayByTypeForRand(
bind,
- stbInfo->columns[i-1].dataType,
+ stbInfo->columns[i-1].data_type,
stbInfo->columns[i-1].dataLen,
timePrec,
&ptr,
NULL)) {
- tmfree(bindBuffer);
return -1;
}
}
- tmfree(bindBuffer);
- return 0;
-}
-
-static int32_t prepareStbStmtBindStartTime(
- char *tableName,
- int64_t *ts,
- char *bindArray, SSuperTable *stbInfo,
- int64_t startTime, int32_t recSeq,
- int32_t timePrec)
-{
- TAOS_BIND *bind;
-
- bind = (TAOS_BIND *)bindArray;
-
- int64_t *bind_ts = ts;
-
- bind->buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
- if (stbInfo->disorderRatio) {
- *bind_ts = startTime + getTSRandTail(
- stbInfo->timeStampStep, recSeq,
- stbInfo->disorderRatio,
- stbInfo->disorderRange);
- } else {
- *bind_ts = startTime + stbInfo->timeStampStep * recSeq;
- }
-
- verbosePrint("%s() LN%d, tableName: %s, bind_ts=%"PRId64"\n",
- __func__, __LINE__, tableName, *bind_ts);
-
- bind->buffer_length = sizeof(int64_t);
- bind->buffer = bind_ts;
- bind->length = &bind->buffer_length;
- bind->is_null = NULL;
-
return 0;
}
@@ -7229,7 +7657,8 @@ UNUSED_FUNC static int32_t prepareStbStmtRand(
return k;
}
-static int32_t prepareStbStmtWithSample(
+#if STMT_BIND_PARAM_BATCH == 1
+static int execBindParamBatch(
threadInfo *pThreadInfo,
char *tableName,
int64_t tableSeq,
@@ -7240,94 +7669,182 @@ static int32_t prepareStbStmtWithSample(
int64_t *pSamplePos)
{
int ret;
- SSuperTable *stbInfo = pThreadInfo->stbInfo;
TAOS_STMT *stmt = pThreadInfo->stmt;
- if (AUTO_CREATE_SUBTBL == stbInfo->autoCreateTable) {
- char* tagsValBuf = NULL;
+ SSuperTable *stbInfo = pThreadInfo->stbInfo;
+ uint32_t columnCount = (stbInfo)?pThreadInfo->stbInfo->columnCount:g_args.columnCount;
+
+ uint32_t thisBatch = MAX_SAMPLES - (*pSamplePos);
+
+ if (thisBatch > batch) {
+ thisBatch = batch;
+ }
+ verbosePrint("%s() LN%d, batch=%d pos=%"PRId64" thisBatch=%d\n",
+ __func__, __LINE__, batch, *pSamplePos, thisBatch);
+
+ memset(pThreadInfo->bindParams, 0,
+ (sizeof(TAOS_MULTI_BIND) * (columnCount + 1)));
+ memset(pThreadInfo->is_null, 0, thisBatch);
+
+ for (int c = 0; c < columnCount + 1; c ++) {
+ TAOS_MULTI_BIND *param = (TAOS_MULTI_BIND *)(pThreadInfo->bindParams + sizeof(TAOS_MULTI_BIND) * c);
+
+ char data_type;
+
+ if (c == 0) {
+ data_type = TSDB_DATA_TYPE_TIMESTAMP;
+ param->buffer_length = sizeof(int64_t);
+ param->buffer = pThreadInfo->bind_ts_array;
- if (0 == stbInfo->tagSource) {
- tagsValBuf = generateTagValuesForStb(stbInfo, tableSeq);
} else {
- tagsValBuf = getTagValueFromTagSample(
- stbInfo,
- tableSeq % stbInfo->tagSampleCount);
- }
+ data_type = (stbInfo)?stbInfo->columns[c-1].data_type:g_args.data_type[c-1];
- if (NULL == tagsValBuf) {
- errorPrint2("%s() LN%d, tag buf failed to allocate memory\n",
- __func__, __LINE__);
- return -1;
- }
+ char *tmpP;
- char *tagsArray = calloc(1, sizeof(TAOS_BIND) * stbInfo->tagCount);
- if (NULL == tagsArray) {
- tmfree(tagsValBuf);
- errorPrint2("%s() LN%d, tag buf failed to allocate memory\n",
- __func__, __LINE__);
- return -1;
- }
+ switch(data_type) {
+ case TSDB_DATA_TYPE_BINARY:
+ case TSDB_DATA_TYPE_NCHAR:
+ param->buffer_length =
+ ((stbInfo)?stbInfo->columns[c-1].dataLen:g_args.binwidth);
- if (-1 == prepareStbStmtBindTag(
- tagsArray, stbInfo, tagsValBuf, pThreadInfo->time_precision
- /* is tag */)) {
- tmfree(tagsValBuf);
- tmfree(tagsArray);
- return -1;
- }
+ tmpP =
+ (char *)((uintptr_t)*(uintptr_t*)(stbInfo->sampleBindBatchArray
+ +sizeof(char*)*(c-1)));
- ret = taos_stmt_set_tbname_tags(stmt, tableName, (TAOS_BIND *)tagsArray);
+ verbosePrint("%s() LN%d, tmpP=%p pos=%"PRId64" width=%d position=%"PRId64"\n",
+ __func__, __LINE__, tmpP, *pSamplePos,
+ (((stbInfo)?stbInfo->columns[c-1].dataLen:g_args.binwidth)),
+ (*pSamplePos) *
+ (((stbInfo)?stbInfo->columns[c-1].dataLen:g_args.binwidth)));
- tmfree(tagsValBuf);
- tmfree(tagsArray);
+ param->buffer = (void *)(tmpP + *pSamplePos *
+ (((stbInfo)?stbInfo->columns[c-1].dataLen:g_args.binwidth))
+ );
+ break;
- if (0 != ret) {
- errorPrint2("%s() LN%d, stmt_set_tbname_tags() failed! reason: %s\n",
- __func__, __LINE__, taos_stmt_errstr(stmt));
- return -1;
+ case TSDB_DATA_TYPE_INT:
+ param->buffer_length = sizeof(int32_t);
+ param->buffer = (stbInfo)?
+ (void *)((uintptr_t)*(uintptr_t*)(stbInfo->sampleBindBatchArray+sizeof(char*)*(c-1))
+ + stbInfo->columns[c-1].dataLen * (*pSamplePos)):
+ (void *)((uintptr_t)*(uintptr_t*)(g_sampleBindBatchArray+sizeof(char*)*(c-1))
+ + sizeof(int32_t)*(*pSamplePos));
+ break;
+
+ case TSDB_DATA_TYPE_TINYINT:
+ param->buffer_length = sizeof(int8_t);
+ param->buffer = (stbInfo)?
+ (void *)((uintptr_t)*(uintptr_t*)(
+ stbInfo->sampleBindBatchArray
+ +sizeof(char*)*(c-1))
+ + stbInfo->columns[c-1].dataLen*(*pSamplePos)):
+ (void *)((uintptr_t)*(uintptr_t*)(
+ g_sampleBindBatchArray+sizeof(char*)*(c-1))
+ + sizeof(int8_t)*(*pSamplePos));
+ break;
+
+ case TSDB_DATA_TYPE_SMALLINT:
+ param->buffer_length = sizeof(int16_t);
+ param->buffer = (stbInfo)?
+ (void *)((uintptr_t)*(uintptr_t*)(stbInfo->sampleBindBatchArray+sizeof(char*)*(c-1))
+ + stbInfo->columns[c-1].dataLen * (*pSamplePos)):
+ (void *)((uintptr_t)*(uintptr_t*)(g_sampleBindBatchArray+sizeof(char*)*(c-1))
+ + sizeof(int16_t)*(*pSamplePos));
+ break;
+
+ case TSDB_DATA_TYPE_BIGINT:
+ param->buffer_length = sizeof(int64_t);
+ param->buffer = (stbInfo)?
+ (void *)((uintptr_t)*(uintptr_t*)(stbInfo->sampleBindBatchArray+sizeof(char*)*(c-1))
+ + stbInfo->columns[c-1].dataLen * (*pSamplePos)):
+ (void *)((uintptr_t)*(uintptr_t*)(g_sampleBindBatchArray+sizeof(char*)*(c-1))
+ + sizeof(int64_t)*(*pSamplePos));
+ break;
+
+ case TSDB_DATA_TYPE_BOOL:
+ param->buffer_length = sizeof(int8_t);
+ param->buffer = (stbInfo)?
+ (void *)((uintptr_t)*(uintptr_t*)(stbInfo->sampleBindBatchArray+sizeof(char*)*(c-1))
+ + stbInfo->columns[c-1].dataLen * (*pSamplePos)):
+ (void *)((uintptr_t)*(uintptr_t*)(g_sampleBindBatchArray+sizeof(char*)*(c-1))
+ + sizeof(int8_t)*(*pSamplePos));
+ break;
+
+ case TSDB_DATA_TYPE_FLOAT:
+ param->buffer_length = sizeof(float);
+ param->buffer = (stbInfo)?
+ (void *)((uintptr_t)*(uintptr_t*)(stbInfo->sampleBindBatchArray+sizeof(char*)*(c-1))
+ + stbInfo->columns[c-1].dataLen * (*pSamplePos)):
+ (void *)((uintptr_t)*(uintptr_t*)(g_sampleBindBatchArray+sizeof(char*)*(c-1))
+ + sizeof(float)*(*pSamplePos));
+ break;
+
+ case TSDB_DATA_TYPE_DOUBLE:
+ param->buffer_length = sizeof(double);
+ param->buffer = (stbInfo)?
+ (void *)((uintptr_t)*(uintptr_t*)(stbInfo->sampleBindBatchArray+sizeof(char*)*(c-1))
+ + stbInfo->columns[c-1].dataLen * (*pSamplePos)):
+ (void *)((uintptr_t)*(uintptr_t*)(g_sampleBindBatchArray+sizeof(char*)*(c-1))
+ + sizeof(double)*(*pSamplePos));
+ break;
+
+ case TSDB_DATA_TYPE_TIMESTAMP:
+ param->buffer_length = sizeof(int64_t);
+ param->buffer = (stbInfo)?
+ (void *)((uintptr_t)*(uintptr_t*)(stbInfo->sampleBindBatchArray+sizeof(char*)*(c-1))
+ + stbInfo->columns[c-1].dataLen * (*pSamplePos)):
+ (void *)((uintptr_t)*(uintptr_t*)(g_sampleBindBatchArray+sizeof(char*)*(c-1))
+ + sizeof(int64_t)*(*pSamplePos));
+ break;
+
+ default:
+ errorPrint("%s() LN%d, wrong data type: %d\n",
+ __func__,
+ __LINE__,
+ data_type);
+ exit(EXIT_FAILURE);
+
+ }
}
- } else {
- ret = taos_stmt_set_tbname(stmt, tableName);
- if (0 != ret) {
- errorPrint2("%s() LN%d, stmt_set_tbname() failed! reason: %s\n",
- __func__, __LINE__, taos_stmt_errstr(stmt));
- return -1;
+
+ param->buffer_type = data_type;
+ param->length = malloc(sizeof(int32_t) * thisBatch);
+ assert(param->length);
+
+ for (int b = 0; b < thisBatch; b++) {
+ if (param->buffer_type == TSDB_DATA_TYPE_NCHAR) {
+ param->length[b] = strlen(
+ (char *)param->buffer + b *
+ ((stbInfo)?stbInfo->columns[c].dataLen:g_args.binwidth)
+ );
+ } else {
+ param->length[b] = param->buffer_length;
+ }
}
+ param->is_null = pThreadInfo->is_null;
+ param->num = thisBatch;
}
uint32_t k;
- for (k = 0; k < batch;) {
- char *bindArray = (char *)(*((uintptr_t *)
- (pThreadInfo->sampleBindArray + (sizeof(char *)) * (*pSamplePos))));
+ for (k = 0; k < thisBatch;) {
/* columnCount + 1 (ts) */
- if (-1 == prepareStbStmtBindStartTime(
- tableName,
- pThreadInfo->bind_ts,
- bindArray, stbInfo,
- startTime, k,
- pThreadInfo->time_precision
- /* is column */)) {
- return -1;
- }
- ret = taos_stmt_bind_param(stmt, (TAOS_BIND *)bindArray);
- if (0 != ret) {
- errorPrint2("%s() LN%d, stmt_bind_param() failed! reason: %s\n",
- __func__, __LINE__, taos_stmt_errstr(stmt));
- return -1;
- }
- // if msg > 3MB, break
- ret = taos_stmt_add_batch(stmt);
- if (0 != ret) {
- errorPrint2("%s() LN%d, stmt_add_batch() failed! reason: %s\n",
- __func__, __LINE__, taos_stmt_errstr(stmt));
- return -1;
+ if (stbInfo->disorderRatio) {
+ *(pThreadInfo->bind_ts_array + k) = startTime + getTSRandTail(
+ stbInfo->timeStampStep, k,
+ stbInfo->disorderRatio,
+ stbInfo->disorderRange);
+ } else {
+ *(pThreadInfo->bind_ts_array + k) = startTime + stbInfo->timeStampStep * k;
}
+ debugPrint("%s() LN%d, k=%d ts=%"PRId64"\n",
+ __func__, __LINE__,
+ k, *(pThreadInfo->bind_ts_array +k));
k++;
recordFrom ++;
(*pSamplePos) ++;
- if ((*pSamplePos) == MAX_SAMPLES_ONCE_FROM_FILE) {
+ if ((*pSamplePos) == MAX_SAMPLES) {
*pSamplePos = 0;
}
@@ -7336,92 +7853,1071 @@ static int32_t prepareStbStmtWithSample(
}
}
+ ret = taos_stmt_bind_param_batch(stmt, (TAOS_MULTI_BIND *)pThreadInfo->bindParams);
+ if (0 != ret) {
+ errorPrint2("%s() LN%d, stmt_bind_param() failed! reason: %s\n",
+ __func__, __LINE__, taos_stmt_errstr(stmt));
+ return -1;
+ }
+
+ for (int c = 0; c < stbInfo->columnCount + 1; c ++) {
+ TAOS_MULTI_BIND *param = (TAOS_MULTI_BIND *)(pThreadInfo->bindParams + sizeof(TAOS_MULTI_BIND) * c);
+ free(param->length);
+ }
+
+ // if msg > 3MB, break
+ ret = taos_stmt_add_batch(stmt);
+ if (0 != ret) {
+ errorPrint2("%s() LN%d, stmt_add_batch() failed! reason: %s\n",
+ __func__, __LINE__, taos_stmt_errstr(stmt));
+ return -1;
+ }
return k;
}
-static int32_t generateStbProgressiveData(
- SSuperTable *stbInfo,
- char *tableName,
- int64_t tableSeq,
- char *dbName, char *buffer,
- int64_t insertRows,
- uint64_t recordFrom, int64_t startTime, int64_t *pSamplePos,
- int64_t *pRemainderBufLen)
+static int parseSamplefileToStmtBatch(
+ SSuperTable* stbInfo)
{
- assert(buffer != NULL);
- char *pstr = buffer;
+ // char *sampleDataBuf = (stbInfo)?
+ // stbInfo->sampleDataBuf:g_sampleDataBuf;
+ int32_t columnCount = (stbInfo)?stbInfo->columnCount:g_args.columnCount;
+ char *sampleBindBatchArray = NULL;
- memset(pstr, 0, *pRemainderBufLen);
+ if (stbInfo) {
+ stbInfo->sampleBindBatchArray = calloc(1, sizeof(uintptr_t *) * columnCount);
+ sampleBindBatchArray = stbInfo->sampleBindBatchArray;
+ } else {
+ g_sampleBindBatchArray = calloc(1, sizeof(uintptr_t *) * columnCount);
+ sampleBindBatchArray = g_sampleBindBatchArray;
+ }
+ assert(sampleBindBatchArray);
- int64_t headLen = generateStbSQLHead(
- stbInfo,
- tableName, tableSeq, dbName,
- buffer, *pRemainderBufLen);
+ for (int c = 0; c < columnCount; c++) {
+ char data_type = (stbInfo)?stbInfo->columns[c].data_type:g_args.data_type[c];
+
+ char *tmpP = NULL;
+
+ switch(data_type) {
+ case TSDB_DATA_TYPE_INT:
+ tmpP = calloc(1, sizeof(int) * MAX_SAMPLES);
+ assert(tmpP);
+ *(uintptr_t*)(sampleBindBatchArray+ sizeof(uintptr_t*)*c) = (uintptr_t)tmpP;
+ break;
+
+ case TSDB_DATA_TYPE_TINYINT:
+ tmpP = calloc(1, sizeof(int8_t) * MAX_SAMPLES);
+ assert(tmpP);
+ *(uintptr_t*)(sampleBindBatchArray+ sizeof(uintptr_t*)*c) = (uintptr_t)tmpP;
+ break;
+
+ case TSDB_DATA_TYPE_SMALLINT:
+ tmpP = calloc(1, sizeof(int16_t) * MAX_SAMPLES);
+ assert(tmpP);
+ *(uintptr_t*)(sampleBindBatchArray+ sizeof(uintptr_t*)*c) = (uintptr_t)tmpP;
+ break;
+
+ case TSDB_DATA_TYPE_BIGINT:
+ tmpP = calloc(1, sizeof(int64_t) * MAX_SAMPLES);
+ assert(tmpP);
+ *(uintptr_t*)(sampleBindBatchArray+ sizeof(uintptr_t*)*c) = (uintptr_t)tmpP;
+ break;
+
+ case TSDB_DATA_TYPE_BOOL:
+ tmpP = calloc(1, sizeof(int8_t) * MAX_SAMPLES);
+ assert(tmpP);
+ *(uintptr_t*)(sampleBindBatchArray+ sizeof(uintptr_t*)*c) = (uintptr_t)tmpP;
+ break;
+
+ case TSDB_DATA_TYPE_FLOAT:
+ tmpP = calloc(1, sizeof(float) * MAX_SAMPLES);
+ assert(tmpP);
+ *(uintptr_t*)(sampleBindBatchArray+ sizeof(uintptr_t*)*c) = (uintptr_t)tmpP;
+ break;
+
+ case TSDB_DATA_TYPE_DOUBLE:
+ tmpP = calloc(1, sizeof(double) * MAX_SAMPLES);
+ assert(tmpP);
+ *(uintptr_t*)(sampleBindBatchArray+ sizeof(uintptr_t*)*c) = (uintptr_t)tmpP;
+ break;
+
+ case TSDB_DATA_TYPE_BINARY:
+ case TSDB_DATA_TYPE_NCHAR:
+ tmpP = calloc(1, MAX_SAMPLES *
+ (((stbInfo)?stbInfo->columns[c].dataLen:g_args.binwidth)));
+ assert(tmpP);
+ *(uintptr_t*)(sampleBindBatchArray+ sizeof(uintptr_t*)*c) = (uintptr_t)tmpP;
+ break;
+
+ case TSDB_DATA_TYPE_TIMESTAMP:
+ tmpP = calloc(1, sizeof(int64_t) * MAX_SAMPLES);
+ assert(tmpP);
+ *(uintptr_t*)(sampleBindBatchArray+ sizeof(uintptr_t*)*c) = (uintptr_t)tmpP;
+ break;
+
+ default:
+ errorPrint("Unknown data type: %s\n",
+ (stbInfo)?stbInfo->columns[c].dataType:g_args.dataType[c]);
+ exit(EXIT_FAILURE);
+ }
+ }
+
+ char *sampleDataBuf = (stbInfo)?stbInfo->sampleDataBuf:g_sampleDataBuf;
+ int64_t lenOfOneRow = (stbInfo)?stbInfo->lenOfOneRow:g_args.lenOfOneRow;
+
+ for (int i=0; i < MAX_SAMPLES; i++) {
+ int cursor = 0;
+
+ for (int c = 0; c < columnCount; c++) {
+ char data_type = (stbInfo)?
+ stbInfo->columns[c].data_type:
+ g_args.data_type[c];
+ char *restStr = sampleDataBuf
+ + lenOfOneRow * i + cursor;
+ int lengthOfRest = strlen(restStr);
+
+ int index = 0;
+ for (index = 0; index < lengthOfRest; index ++) {
+ if (restStr[index] == ',') {
+ break;
+ }
+ }
+
+ char *tmpStr = calloc(1, index + 1);
+ if (NULL == tmpStr) {
+ errorPrint2("%s() LN%d, Failed to allocate %d bind buffer\n",
+ __func__, __LINE__, index + 1);
+ return -1;
+ }
+
+ strncpy(tmpStr, restStr, index);
+ cursor += index + 1; // skip ',' too
+ char *tmpP;
+
+ switch(data_type) {
+ case TSDB_DATA_TYPE_INT:
+ *((int32_t*)((uintptr_t)*(uintptr_t*)(sampleBindBatchArray
+ +sizeof(char*)*c)+sizeof(int32_t)*i)) =
+ atoi(tmpStr);
+ break;
+
+ case TSDB_DATA_TYPE_FLOAT:
+ *(float*)(((uintptr_t)*(uintptr_t*)(sampleBindBatchArray
+ +sizeof(char*)*c)+sizeof(float)*i)) =
+ (float)atof(tmpStr);
+ break;
+
+ case TSDB_DATA_TYPE_DOUBLE:
+ *(double*)(((uintptr_t)*(uintptr_t*)(sampleBindBatchArray
+ +sizeof(char*)*c)+sizeof(double)*i)) =
+ atof(tmpStr);
+ break;
+
+ case TSDB_DATA_TYPE_TINYINT:
+ *((int8_t*)((uintptr_t)*(uintptr_t*)(sampleBindBatchArray
+ +sizeof(char*)*c)+sizeof(int8_t)*i)) =
+ (int8_t)atoi(tmpStr);
+ break;
+
+ case TSDB_DATA_TYPE_SMALLINT:
+ *((int16_t*)((uintptr_t)*(uintptr_t*)(sampleBindBatchArray
+ +sizeof(char*)*c)+sizeof(int16_t)*i)) =
+ (int16_t)atoi(tmpStr);
+ break;
+
+ case TSDB_DATA_TYPE_BIGINT:
+ *((int64_t*)((uintptr_t)*(uintptr_t*)(sampleBindBatchArray
+ +sizeof(char*)*c)+sizeof(int64_t)*i)) =
+ (int64_t)atol(tmpStr);
+ break;
+
+ case TSDB_DATA_TYPE_BOOL:
+ *((int8_t*)((uintptr_t)*(uintptr_t*)(sampleBindBatchArray
+ +sizeof(char*)*c)+sizeof(int8_t)*i)) =
+ (int8_t)atoi(tmpStr);
+ break;
+
+ case TSDB_DATA_TYPE_TIMESTAMP:
+ *((int64_t*)((uintptr_t)*(uintptr_t*)(sampleBindBatchArray
+ +sizeof(char*)*c)+sizeof(int64_t)*i)) =
+ (int64_t)atol(tmpStr);
+ break;
+
+ case TSDB_DATA_TYPE_BINARY:
+ case TSDB_DATA_TYPE_NCHAR:
+ tmpP = (char *)(*(uintptr_t*)(sampleBindBatchArray
+ +sizeof(char*)*c));
+ strcpy(tmpP + i*
+ (((stbInfo)?stbInfo->columns[c].dataLen:g_args.binwidth))
+ , tmpStr);
+ break;
+
+ default:
+ break;
+ }
+
+ free(tmpStr);
+ }
+ }
+
+ return 0;
+}
+
+static int parseSampleToStmtBatchForThread(
+ threadInfo *pThreadInfo, SSuperTable *stbInfo,
+ uint32_t timePrec,
+ uint32_t batch)
+{
+ uint32_t columnCount = (stbInfo)?stbInfo->columnCount:g_args.columnCount;
+
+ pThreadInfo->bind_ts_array = malloc(sizeof(int64_t) * batch);
+ assert(pThreadInfo->bind_ts_array);
+
+ pThreadInfo->bindParams = malloc(sizeof(TAOS_MULTI_BIND) * (columnCount + 1));
+ assert(pThreadInfo->bindParams);
+
+ pThreadInfo->is_null = malloc(batch);
+ assert(pThreadInfo->is_null);
+
+ return 0;
+}
+
+static int parseStbSampleToStmtBatchForThread(
+ threadInfo *pThreadInfo,
+ SSuperTable *stbInfo,
+ uint32_t timePrec,
+ uint32_t batch)
+{
+ return parseSampleToStmtBatchForThread(
+ pThreadInfo, stbInfo, timePrec, batch);
+}
+
+static int parseNtbSampleToStmtBatchForThread(
+ threadInfo *pThreadInfo, uint32_t timePrec, uint32_t batch)
+{
+ return parseSampleToStmtBatchForThread(
+ pThreadInfo, NULL, timePrec, batch);
+}
+
+#else
+static int parseSampleToStmt(
+ threadInfo *pThreadInfo,
+ SSuperTable *stbInfo, uint32_t timePrec)
+{
+ pThreadInfo->sampleBindArray =
+ calloc(1, sizeof(char *) * MAX_SAMPLES);
+ if (pThreadInfo->sampleBindArray == NULL) {
+ errorPrint2("%s() LN%d, Failed to allocate %"PRIu64" bind array buffer\n",
+ __func__, __LINE__,
+ (uint64_t)sizeof(char *) * MAX_SAMPLES);
+ return -1;
+ }
+
+ int32_t columnCount = (stbInfo)?stbInfo->columnCount:g_args.columnCount;
+ char *sampleDataBuf = (stbInfo)?stbInfo->sampleDataBuf:g_sampleDataBuf;
+ int64_t lenOfOneRow = (stbInfo)?stbInfo->lenOfOneRow:g_args.lenOfOneRow;
+
+ for (int i=0; i < MAX_SAMPLES; i++) {
+ char *bindArray =
+ calloc(1, sizeof(TAOS_BIND) * (columnCount + 1));
+ if (bindArray == NULL) {
+ errorPrint2("%s() LN%d, Failed to allocate %d bind params\n",
+ __func__, __LINE__, (columnCount + 1));
+ return -1;
+ }
+
+ TAOS_BIND *bind;
+ int cursor = 0;
+
+ for (int c = 0; c < columnCount + 1; c++) {
+ bind = (TAOS_BIND *)((char *)bindArray + (sizeof(TAOS_BIND) * c));
+
+ if (c == 0) {
+ bind->buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
+ bind->buffer_length = sizeof(int64_t);
+ bind->buffer = NULL; //bind_ts;
+ bind->length = &bind->buffer_length;
+ bind->is_null = NULL;
+ } else {
+ char data_type = (stbInfo)?
+ stbInfo->columns[c-1].data_type:
+ g_args.data_type[c-1];
+ int32_t dataLen = (stbInfo)?
+ stbInfo->columns[c-1].dataLen:
+ g_args.binwidth;
+ char *restStr = sampleDataBuf
+ + lenOfOneRow * i + cursor;
+ int lengthOfRest = strlen(restStr);
+
+ int index = 0;
+ for (index = 0; index < lengthOfRest; index ++) {
+ if (restStr[index] == ',') {
+ break;
+ }
+ }
+
+ char *bindBuffer = calloc(1, index + 1);
+ if (bindBuffer == NULL) {
+ errorPrint2("%s() LN%d, Failed to allocate %d bind buffer\n",
+ __func__, __LINE__, index + 1);
+ return -1;
+ }
+
+ strncpy(bindBuffer, restStr, index);
+ cursor += index + 1; // skip ',' too
+
+ if (-1 == prepareStmtBindArrayByType(
+ bind,
+ data_type,
+ dataLen,
+ timePrec,
+ bindBuffer)) {
+ free(bindBuffer);
+ return -1;
+ }
+ free(bindBuffer);
+ }
+ }
+ *((uintptr_t *)(pThreadInfo->sampleBindArray + (sizeof(char *)) * i)) =
+ (uintptr_t)bindArray;
+ }
+
+ return 0;
+}
+
+static int parseStbSampleToStmt(
+ threadInfo *pThreadInfo,
+ SSuperTable *stbInfo, uint32_t timePrec)
+{
+ return parseSampleToStmt(
+ pThreadInfo,
+ stbInfo, timePrec);
+}
+
+static int parseNtbSampleToStmt(
+ threadInfo *pThreadInfo,
+ uint32_t timePrec)
+{
+ return parseSampleToStmt(
+ pThreadInfo,
+ NULL,
+ timePrec);
+}
+
+static int32_t prepareStbStmtBindStartTime(
+ char *tableName,
+ int64_t *ts,
+ char *bindArray, SSuperTable *stbInfo,
+ int64_t startTime, int32_t recSeq)
+{
+ TAOS_BIND *bind;
+
+ bind = (TAOS_BIND *)bindArray;
+
+ int64_t *bind_ts = ts;
+
+ bind->buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
+ if (stbInfo->disorderRatio) {
+ *bind_ts = startTime + getTSRandTail(
+ stbInfo->timeStampStep, recSeq,
+ stbInfo->disorderRatio,
+ stbInfo->disorderRange);
+ } else {
+ *bind_ts = startTime + stbInfo->timeStampStep * recSeq;
+ }
+
+ verbosePrint("%s() LN%d, tableName: %s, bind_ts=%"PRId64"\n",
+ __func__, __LINE__, tableName, *bind_ts);
+
+ bind->buffer_length = sizeof(int64_t);
+ bind->buffer = bind_ts;
+ bind->length = &bind->buffer_length;
+ bind->is_null = NULL;
+
+ return 0;
+}
+
+static uint32_t execBindParam(
+ threadInfo *pThreadInfo,
+ char *tableName,
+ int64_t tableSeq,
+ uint32_t batch,
+ uint64_t insertRows,
+ uint64_t recordFrom,
+ int64_t startTime,
+ int64_t *pSamplePos)
+{
+ int ret;
+ SSuperTable *stbInfo = pThreadInfo->stbInfo;
+ TAOS_STMT *stmt = pThreadInfo->stmt;
+
+ uint32_t k;
+ for (k = 0; k < batch;) {
+ char *bindArray = (char *)(*((uintptr_t *)
+ (pThreadInfo->sampleBindArray + (sizeof(char *)) * (*pSamplePos))));
+ /* columnCount + 1 (ts) */
+ if (-1 == prepareStbStmtBindStartTime(
+ tableName,
+ pThreadInfo->bind_ts,
+ bindArray, stbInfo,
+ startTime, k
+ /* is column */)) {
+ return -1;
+ }
+ ret = taos_stmt_bind_param(stmt, (TAOS_BIND *)bindArray);
+ if (0 != ret) {
+ errorPrint2("%s() LN%d, stmt_bind_param() failed! reason: %s\n",
+ __func__, __LINE__, taos_stmt_errstr(stmt));
+ return -1;
+ }
+ // if msg > 3MB, break
+ ret = taos_stmt_add_batch(stmt);
+ if (0 != ret) {
+ errorPrint2("%s() LN%d, stmt_add_batch() failed! reason: %s\n",
+ __func__, __LINE__, taos_stmt_errstr(stmt));
+ return -1;
+ }
+
+ k++;
+ recordFrom ++;
+
+ (*pSamplePos) ++;
+ if ((*pSamplePos) == MAX_SAMPLES) {
+ *pSamplePos = 0;
+ }
+
+ if (recordFrom >= insertRows) {
+ break;
+ }
+ }
+
+ return k;
+}
+#endif
+
+static int32_t prepareStbStmtWithSample(
+ threadInfo *pThreadInfo,
+ char *tableName,
+ int64_t tableSeq,
+ uint32_t batch,
+ uint64_t insertRows,
+ uint64_t recordFrom,
+ int64_t startTime,
+ int64_t *pSamplePos)
+{
+ int ret;
+ SSuperTable *stbInfo = pThreadInfo->stbInfo;
+ TAOS_STMT *stmt = pThreadInfo->stmt;
+
+ if (AUTO_CREATE_SUBTBL == stbInfo->autoCreateTable) {
+ char* tagsValBuf = NULL;
+
+ if (0 == stbInfo->tagSource) {
+ tagsValBuf = generateTagValuesForStb(stbInfo, tableSeq);
+ } else {
+ tagsValBuf = getTagValueFromTagSample(
+ stbInfo,
+ tableSeq % stbInfo->tagSampleCount);
+ }
+
+ if (NULL == tagsValBuf) {
+ errorPrint2("%s() LN%d, tag buf failed to allocate memory\n",
+ __func__, __LINE__);
+ return -1;
+ }
+
+ char *tagsArray = calloc(1, sizeof(TAOS_BIND) * stbInfo->tagCount);
+ if (NULL == tagsArray) {
+ tmfree(tagsValBuf);
+ errorPrint2("%s() LN%d, tag buf failed to allocate memory\n",
+ __func__, __LINE__);
+ return -1;
+ }
+
+ if (-1 == prepareStbStmtBindTag(
+ tagsArray, stbInfo, tagsValBuf, pThreadInfo->time_precision
+ /* is tag */)) {
+ tmfree(tagsValBuf);
+ tmfree(tagsArray);
+ return -1;
+ }
+
+ ret = taos_stmt_set_tbname_tags(stmt, tableName, (TAOS_BIND *)tagsArray);
+
+ tmfree(tagsValBuf);
+ tmfree(tagsArray);
+
+ if (0 != ret) {
+ errorPrint2("%s() LN%d, stmt_set_tbname_tags() failed! reason: %s\n",
+ __func__, __LINE__, taos_stmt_errstr(stmt));
+ return -1;
+ }
+ } else {
+ ret = taos_stmt_set_tbname(stmt, tableName);
+ if (0 != ret) {
+ errorPrint2("%s() LN%d, stmt_set_tbname() failed! reason: %s\n",
+ __func__, __LINE__, taos_stmt_errstr(stmt));
+ return -1;
+ }
+ }
+
+#if STMT_BIND_PARAM_BATCH == 1
+ return execBindParamBatch(
+ pThreadInfo,
+ tableName,
+ tableSeq,
+ batch,
+ insertRows,
+ recordFrom,
+ startTime,
+ pSamplePos);
+#else
+ return execBindParam(
+ pThreadInfo,
+ tableName,
+ tableSeq,
+ batch,
+ insertRows,
+ recordFrom,
+ startTime,
+ pSamplePos);
+#endif
+}
+
+static int32_t generateStbProgressiveData(
+ SSuperTable *stbInfo,
+ char *tableName,
+ int64_t tableSeq,
+ char *dbName, char *buffer,
+ int64_t insertRows,
+ uint64_t recordFrom, int64_t startTime, int64_t *pSamplePos,
+ int64_t *pRemainderBufLen)
+{
+ assert(buffer != NULL);
+ char *pstr = buffer;
+
+ memset(pstr, 0, *pRemainderBufLen);
+
+ int64_t headLen = generateStbSQLHead(
+ stbInfo,
+ tableName, tableSeq, dbName,
+ buffer, *pRemainderBufLen);
+
+ if (headLen <= 0) {
+ return 0;
+ }
+ pstr += headLen;
+ *pRemainderBufLen -= headLen;
+
+ int64_t dataLen;
+
+ return generateStbDataTail(stbInfo,
+ g_args.reqPerReq, pstr, *pRemainderBufLen,
+ insertRows, recordFrom,
+ startTime,
+ pSamplePos, &dataLen);
+}
+
+static int32_t generateProgressiveDataWithoutStb(
+ char *tableName,
+ /* int64_t tableSeq, */
+ threadInfo *pThreadInfo, char *buffer,
+ int64_t insertRows,
+ uint64_t recordFrom, int64_t startTime, /*int64_t *pSamplePos, */
+ int64_t *pRemainderBufLen)
+{
+ assert(buffer != NULL);
+ char *pstr = buffer;
+
+ memset(buffer, 0, *pRemainderBufLen);
+
+ int64_t headLen = generateSQLHeadWithoutStb(
+ tableName, pThreadInfo->db_name,
+ buffer, *pRemainderBufLen);
+
+ if (headLen <= 0) {
+ return 0;
+ }
+ pstr += headLen;
+ *pRemainderBufLen -= headLen;
+
+ int64_t dataLen;
+
+ return generateDataTailWithoutStb(
+ g_args.reqPerReq, pstr, *pRemainderBufLen, insertRows, recordFrom,
+ startTime,
+ /*pSamplePos, */&dataLen);
+}
+
+static void printStatPerThread(threadInfo *pThreadInfo)
+{
+ if (0 == pThreadInfo->totalDelay)
+ pThreadInfo->totalDelay = 1;
+
+ fprintf(stderr, "====thread[%d] completed total inserted rows: %"PRIu64 ", total affected rows: %"PRIu64". %.2f records/second====\n",
+ pThreadInfo->threadID,
+ pThreadInfo->totalInsertRows,
+ pThreadInfo->totalAffectedRows,
+ (double)(pThreadInfo->totalAffectedRows/((double)pThreadInfo->totalDelay/1000000.0))
+ );
+}
+
+#if STMT_BIND_PARAM_BATCH == 1
+// stmt sync write interlace data
+static void* syncWriteInterlaceStmtBatch(threadInfo *pThreadInfo, uint32_t interlaceRows) {
+ debugPrint("[%d] %s() LN%d: ### stmt interlace write\n",
+ pThreadInfo->threadID, __func__, __LINE__);
+
+ int64_t insertRows;
+ uint64_t maxSqlLen;
+ int64_t nTimeStampStep;
+ uint64_t insert_interval;
+
+ SSuperTable* stbInfo = pThreadInfo->stbInfo;
+
+ if (stbInfo) {
+ insertRows = stbInfo->insertRows;
+ maxSqlLen = stbInfo->maxSqlLen;
+ nTimeStampStep = stbInfo->timeStampStep;
+ insert_interval = stbInfo->insertInterval;
+ } else {
+ insertRows = g_args.insertRows;
+ maxSqlLen = g_args.max_sql_len;
+ nTimeStampStep = g_args.timestamp_step;
+ insert_interval = g_args.insert_interval;
+ }
+
+ debugPrint("[%d] %s() LN%d: start_table_from=%"PRIu64" ntables=%"PRId64" insertRows=%"PRIu64"\n",
+ pThreadInfo->threadID, __func__, __LINE__,
+ pThreadInfo->start_table_from,
+ pThreadInfo->ntables, insertRows);
+
+ uint32_t batchPerTbl = interlaceRows;
+ uint32_t batchPerTblTimes;
+
+ if (interlaceRows > g_args.reqPerReq)
+ interlaceRows = g_args.reqPerReq;
+
+ if ((interlaceRows > 0) && (pThreadInfo->ntables > 1)) {
+ batchPerTblTimes =
+ g_args.reqPerReq / interlaceRows;
+ } else {
+ batchPerTblTimes = 1;
+ }
+
+ pThreadInfo->totalInsertRows = 0;
+ pThreadInfo->totalAffectedRows = 0;
+
+ uint64_t st = 0;
+ uint64_t et = UINT64_MAX;
+
+ uint64_t lastPrintTime = taosGetTimestampMs();
+ uint64_t startTs = taosGetTimestampMs();
+ uint64_t endTs;
+
+ uint64_t tableSeq = pThreadInfo->start_table_from;
+ int64_t startTime = pThreadInfo->start_time;
+
+ uint64_t generatedRecPerTbl = 0;
+ bool flagSleep = true;
+ uint64_t sleepTimeTotal = 0;
+
+ int percentComplete = 0;
+ int64_t totalRows = insertRows * pThreadInfo->ntables;
+
+ while(pThreadInfo->totalInsertRows < pThreadInfo->ntables * insertRows) {
+ if ((flagSleep) && (insert_interval)) {
+ st = taosGetTimestampMs();
+ flagSleep = false;
+ }
+
+ uint32_t recOfBatch = 0;
+
+ int32_t generated;
+ for (uint64_t i = 0; i < batchPerTblTimes; i ++) {
+ char tableName[TSDB_TABLE_NAME_LEN];
+
+ getTableName(tableName, pThreadInfo, tableSeq);
+ if (0 == strlen(tableName)) {
+ errorPrint2("[%d] %s() LN%d, getTableName return null\n",
+ pThreadInfo->threadID, __func__, __LINE__);
+ return NULL;
+ }
+
+ if (stbInfo) {
+ generated = prepareStbStmtWithSample(
+ pThreadInfo,
+ tableName,
+ tableSeq,
+ batchPerTbl,
+ insertRows, 0,
+ startTime,
+ &(pThreadInfo->samplePos));
+ } else {
+ debugPrint("[%d] %s() LN%d, tableName:%s, batch:%d startTime:%"PRId64"\n",
+ pThreadInfo->threadID,
+ __func__, __LINE__,
+ tableName, batchPerTbl, startTime);
+ generated = prepareStmtWithoutStb(
+ pThreadInfo,
+ tableName,
+ batchPerTbl,
+ insertRows, i,
+ startTime);
+ }
+
+ debugPrint("[%d] %s() LN%d, generated records is %d\n",
+ pThreadInfo->threadID, __func__, __LINE__, generated);
+ if (generated < 0) {
+ errorPrint2("[%d] %s() LN%d, generated records is %d\n",
+ pThreadInfo->threadID, __func__, __LINE__, generated);
+ goto free_of_interlace_stmt;
+ } else if (generated == 0) {
+ break;
+ }
+
+ tableSeq ++;
+ recOfBatch += batchPerTbl;
+
+ pThreadInfo->totalInsertRows += batchPerTbl;
+
+ verbosePrint("[%d] %s() LN%d batchPerTbl=%d recOfBatch=%d\n",
+ pThreadInfo->threadID, __func__, __LINE__,
+ batchPerTbl, recOfBatch);
+
+ if (tableSeq == pThreadInfo->start_table_from + pThreadInfo->ntables) {
+ // turn to first table
+ tableSeq = pThreadInfo->start_table_from;
+ generatedRecPerTbl += batchPerTbl;
+
+ startTime = pThreadInfo->start_time
+ + generatedRecPerTbl * nTimeStampStep;
+
+ flagSleep = true;
+ if (generatedRecPerTbl >= insertRows)
+ break;
+
+ int64_t remainRows = insertRows - generatedRecPerTbl;
+ if ((remainRows > 0) && (batchPerTbl > remainRows))
+ batchPerTbl = remainRows;
+
+ if (pThreadInfo->ntables * batchPerTbl < g_args.reqPerReq)
+ break;
+ }
+
+ verbosePrint("[%d] %s() LN%d generatedRecPerTbl=%"PRId64" insertRows=%"PRId64"\n",
+ pThreadInfo->threadID, __func__, __LINE__,
+ generatedRecPerTbl, insertRows);
+
+ if ((g_args.reqPerReq - recOfBatch) < batchPerTbl)
+ break;
+ }
+
+ verbosePrint("[%d] %s() LN%d recOfBatch=%d totalInsertRows=%"PRIu64"\n",
+ pThreadInfo->threadID, __func__, __LINE__, recOfBatch,
+ pThreadInfo->totalInsertRows);
+
+ startTs = taosGetTimestampUs();
+
+ if (recOfBatch == 0) {
+ errorPrint2("[%d] %s() LN%d Failed to insert records of batch %d\n",
+ pThreadInfo->threadID, __func__, __LINE__,
+ batchPerTbl);
+ if (batchPerTbl > 0) {
+ errorPrint("\tIf the batch is %d, the length of the SQL to insert a row must be less then %"PRId64"\n",
+ batchPerTbl, maxSqlLen / batchPerTbl);
+ }
+ goto free_of_interlace_stmt;
+ }
+ int64_t affectedRows = execInsert(pThreadInfo, recOfBatch);
+
+ endTs = taosGetTimestampUs();
+ uint64_t delay = endTs - startTs;
+ performancePrint("%s() LN%d, insert execution time is %10.2f ms\n",
+ __func__, __LINE__, delay / 1000.0);
+ verbosePrint("[%d] %s() LN%d affectedRows=%"PRId64"\n",
+ pThreadInfo->threadID,
+ __func__, __LINE__, affectedRows);
+
+ if (delay > pThreadInfo->maxDelay) pThreadInfo->maxDelay = delay;
+ if (delay < pThreadInfo->minDelay) pThreadInfo->minDelay = delay;
+ pThreadInfo->cntDelay++;
+ pThreadInfo->totalDelay += delay;
+
+ if (recOfBatch != affectedRows) {
+ errorPrint2("[%d] %s() LN%d execInsert insert %d, affected rows: %"PRId64"\n\n",
+ pThreadInfo->threadID, __func__, __LINE__,
+ recOfBatch, affectedRows);
+ goto free_of_interlace_stmt;
+ }
+
+ pThreadInfo->totalAffectedRows += affectedRows;
+
+ int currentPercent = pThreadInfo->totalAffectedRows * 100 / totalRows;
+ if (currentPercent > percentComplete ) {
+ printf("[%d]:%d%%\n", pThreadInfo->threadID, currentPercent);
+ percentComplete = currentPercent;
+ }
+ int64_t currentPrintTime = taosGetTimestampMs();
+ if (currentPrintTime - lastPrintTime > 30*1000) {
+ printf("thread[%d] has currently inserted rows: %"PRIu64 ", affected rows: %"PRIu64 "\n",
+ pThreadInfo->threadID,
+ pThreadInfo->totalInsertRows,
+ pThreadInfo->totalAffectedRows);
+ lastPrintTime = currentPrintTime;
+ }
+
+ if ((insert_interval) && flagSleep) {
+ et = taosGetTimestampMs();
+
+ if (insert_interval > (et - st) ) {
+ uint64_t sleepTime = insert_interval - (et -st);
+ performancePrint("%s() LN%d sleep: %"PRId64" ms for insert interval\n",
+ __func__, __LINE__, sleepTime);
+ taosMsleep(sleepTime); // ms
+ sleepTimeTotal += insert_interval;
+ }
+ }
+ }
+ if (percentComplete < 100)
+ printf("[%d]:%d%%\n", pThreadInfo->threadID, percentComplete);
+
+free_of_interlace_stmt:
+ printStatPerThread(pThreadInfo);
+ return NULL;
+}
+#else
+// stmt sync write interlace data
+static void* syncWriteInterlaceStmt(threadInfo *pThreadInfo, uint32_t interlaceRows) {
+ debugPrint("[%d] %s() LN%d: ### stmt interlace write\n",
+ pThreadInfo->threadID, __func__, __LINE__);
+
+ int64_t insertRows;
+ uint64_t maxSqlLen;
+ int64_t nTimeStampStep;
+ uint64_t insert_interval;
+
+ SSuperTable* stbInfo = pThreadInfo->stbInfo;
+
+ if (stbInfo) {
+ insertRows = stbInfo->insertRows;
+ maxSqlLen = stbInfo->maxSqlLen;
+ nTimeStampStep = stbInfo->timeStampStep;
+ insert_interval = stbInfo->insertInterval;
+ } else {
+ insertRows = g_args.insertRows;
+ maxSqlLen = g_args.max_sql_len;
+ nTimeStampStep = g_args.timestamp_step;
+ insert_interval = g_args.insert_interval;
+ }
+
+ debugPrint("[%d] %s() LN%d: start_table_from=%"PRIu64" ntables=%"PRId64" insertRows=%"PRIu64"\n",
+ pThreadInfo->threadID, __func__, __LINE__,
+ pThreadInfo->start_table_from,
+ pThreadInfo->ntables, insertRows);
+
+ uint32_t batchPerTbl = interlaceRows;
+ uint32_t batchPerTblTimes;
+
+ if (interlaceRows > g_args.reqPerReq)
+ interlaceRows = g_args.reqPerReq;
+
+ if ((interlaceRows > 0) && (pThreadInfo->ntables > 1)) {
+ batchPerTblTimes =
+ g_args.reqPerReq / interlaceRows;
+ } else {
+ batchPerTblTimes = 1;
+ }
+
+ pThreadInfo->totalInsertRows = 0;
+ pThreadInfo->totalAffectedRows = 0;
+
+ uint64_t st = 0;
+ uint64_t et = UINT64_MAX;
+
+ uint64_t lastPrintTime = taosGetTimestampMs();
+ uint64_t startTs = taosGetTimestampMs();
+ uint64_t endTs;
+
+ uint64_t tableSeq = pThreadInfo->start_table_from;
+ int64_t startTime = pThreadInfo->start_time;
+
+ uint64_t generatedRecPerTbl = 0;
+ bool flagSleep = true;
+ uint64_t sleepTimeTotal = 0;
+
+ int percentComplete = 0;
+ int64_t totalRows = insertRows * pThreadInfo->ntables;
+
+ while(pThreadInfo->totalInsertRows < pThreadInfo->ntables * insertRows) {
+ if ((flagSleep) && (insert_interval)) {
+ st = taosGetTimestampMs();
+ flagSleep = false;
+ }
+
+ uint32_t recOfBatch = 0;
+
+ int32_t generated;
+ for (uint64_t i = 0; i < batchPerTblTimes; i ++) {
+ char tableName[TSDB_TABLE_NAME_LEN];
+
+ getTableName(tableName, pThreadInfo, tableSeq);
+ if (0 == strlen(tableName)) {
+ errorPrint2("[%d] %s() LN%d, getTableName return null\n",
+ pThreadInfo->threadID, __func__, __LINE__);
+ return NULL;
+ }
+
+ if (stbInfo) {
+ generated = prepareStbStmtWithSample(
+ pThreadInfo,
+ tableName,
+ tableSeq,
+ batchPerTbl,
+ insertRows, 0,
+ startTime,
+ &(pThreadInfo->samplePos));
+ } else {
+ debugPrint("[%d] %s() LN%d, tableName:%s, batch:%d startTime:%"PRId64"\n",
+ pThreadInfo->threadID,
+ __func__, __LINE__,
+ tableName, batchPerTbl, startTime);
+ generated = prepareStmtWithoutStb(
+ pThreadInfo,
+ tableName,
+ batchPerTbl,
+ insertRows, i,
+ startTime);
+ }
+
+ debugPrint("[%d] %s() LN%d, generated records is %d\n",
+ pThreadInfo->threadID, __func__, __LINE__, generated);
+ if (generated < 0) {
+ errorPrint2("[%d] %s() LN%d, generated records is %d\n",
+ pThreadInfo->threadID, __func__, __LINE__, generated);
+ goto free_of_interlace_stmt;
+ } else if (generated == 0) {
+ break;
+ }
+
+ tableSeq ++;
+ recOfBatch += batchPerTbl;
+
+ pThreadInfo->totalInsertRows += batchPerTbl;
+
+ verbosePrint("[%d] %s() LN%d batchPerTbl=%d recOfBatch=%d\n",
+ pThreadInfo->threadID, __func__, __LINE__,
+ batchPerTbl, recOfBatch);
+
+ if (tableSeq == pThreadInfo->start_table_from + pThreadInfo->ntables) {
+ // turn to first table
+ tableSeq = pThreadInfo->start_table_from;
+ generatedRecPerTbl += batchPerTbl;
+
+ startTime = pThreadInfo->start_time
+ + generatedRecPerTbl * nTimeStampStep;
+
+ flagSleep = true;
+ if (generatedRecPerTbl >= insertRows)
+ break;
+
+ int64_t remainRows = insertRows - generatedRecPerTbl;
+ if ((remainRows > 0) && (batchPerTbl > remainRows))
+ batchPerTbl = remainRows;
+
+ if (pThreadInfo->ntables * batchPerTbl < g_args.reqPerReq)
+ break;
+ }
+
+ verbosePrint("[%d] %s() LN%d generatedRecPerTbl=%"PRId64" insertRows=%"PRId64"\n",
+ pThreadInfo->threadID, __func__, __LINE__,
+ generatedRecPerTbl, insertRows);
+
+ if ((g_args.reqPerReq - recOfBatch) < batchPerTbl)
+ break;
+ }
+
+ verbosePrint("[%d] %s() LN%d recOfBatch=%d totalInsertRows=%"PRIu64"\n",
+ pThreadInfo->threadID, __func__, __LINE__, recOfBatch,
+ pThreadInfo->totalInsertRows);
+
+ startTs = taosGetTimestampUs();
+
+ if (recOfBatch == 0) {
+ errorPrint2("[%d] %s() LN%d Failed to insert records of batch %d\n",
+ pThreadInfo->threadID, __func__, __LINE__,
+ batchPerTbl);
+ if (batchPerTbl > 0) {
+ errorPrint("\tIf the batch is %d, the length of the SQL to insert a row must be less then %"PRId64"\n",
+ batchPerTbl, maxSqlLen / batchPerTbl);
+ }
+ goto free_of_interlace_stmt;
+ }
+ int64_t affectedRows = execInsert(pThreadInfo, recOfBatch);
- if (headLen <= 0) {
- return 0;
- }
- pstr += headLen;
- *pRemainderBufLen -= headLen;
+ endTs = taosGetTimestampUs();
+ uint64_t delay = endTs - startTs;
+ performancePrint("%s() LN%d, insert execution time is %10.2f ms\n",
+ __func__, __LINE__, delay / 1000.0);
+ verbosePrint("[%d] %s() LN%d affectedRows=%"PRId64"\n",
+ pThreadInfo->threadID,
+ __func__, __LINE__, affectedRows);
- int64_t dataLen;
+ if (delay > pThreadInfo->maxDelay) pThreadInfo->maxDelay = delay;
+ if (delay < pThreadInfo->minDelay) pThreadInfo->minDelay = delay;
+ pThreadInfo->cntDelay++;
+ pThreadInfo->totalDelay += delay;
- return generateStbDataTail(stbInfo,
- g_args.num_of_RPR, pstr, *pRemainderBufLen,
- insertRows, recordFrom,
- startTime,
- pSamplePos, &dataLen);
-}
+ if (recOfBatch != affectedRows) {
+ errorPrint2("[%d] %s() LN%d execInsert insert %d, affected rows: %"PRId64"\n\n",
+ pThreadInfo->threadID, __func__, __LINE__,
+ recOfBatch, affectedRows);
+ goto free_of_interlace_stmt;
+ }
-static int32_t generateProgressiveDataWithoutStb(
- char *tableName,
- /* int64_t tableSeq, */
- threadInfo *pThreadInfo, char *buffer,
- int64_t insertRows,
- uint64_t recordFrom, int64_t startTime, /*int64_t *pSamplePos, */
- int64_t *pRemainderBufLen)
-{
- assert(buffer != NULL);
- char *pstr = buffer;
+ pThreadInfo->totalAffectedRows += affectedRows;
- memset(buffer, 0, *pRemainderBufLen);
+ int currentPercent = pThreadInfo->totalAffectedRows * 100 / totalRows;
+ if (currentPercent > percentComplete ) {
+ printf("[%d]:%d%%\n", pThreadInfo->threadID, currentPercent);
+ percentComplete = currentPercent;
+ }
+ int64_t currentPrintTime = taosGetTimestampMs();
+ if (currentPrintTime - lastPrintTime > 30*1000) {
+ printf("thread[%d] has currently inserted rows: %"PRIu64 ", affected rows: %"PRIu64 "\n",
+ pThreadInfo->threadID,
+ pThreadInfo->totalInsertRows,
+ pThreadInfo->totalAffectedRows);
+ lastPrintTime = currentPrintTime;
+ }
- int64_t headLen = generateSQLHeadWithoutStb(
- tableName, pThreadInfo->db_name,
- buffer, *pRemainderBufLen);
+ if ((insert_interval) && flagSleep) {
+ et = taosGetTimestampMs();
- if (headLen <= 0) {
- return 0;
+ if (insert_interval > (et - st) ) {
+ uint64_t sleepTime = insert_interval - (et -st);
+ performancePrint("%s() LN%d sleep: %"PRId64" ms for insert interval\n",
+ __func__, __LINE__, sleepTime);
+ taosMsleep(sleepTime); // ms
+ sleepTimeTotal += insert_interval;
+ }
+ }
}
- pstr += headLen;
- *pRemainderBufLen -= headLen;
-
- int64_t dataLen;
+ if (percentComplete < 100)
+ printf("[%d]:%d%%\n", pThreadInfo->threadID, percentComplete);
- return generateDataTailWithoutStb(
- g_args.num_of_RPR, pstr, *pRemainderBufLen, insertRows, recordFrom,
- startTime,
- /*pSamplePos, */&dataLen);
+free_of_interlace_stmt:
+ printStatPerThread(pThreadInfo);
+ return NULL;
}
-static void printStatPerThread(threadInfo *pThreadInfo)
-{
- fprintf(stderr, "====thread[%d] completed total inserted rows: %"PRIu64 ", total affected rows: %"PRIu64". %.2f records/second====\n",
- pThreadInfo->threadID,
- pThreadInfo->totalInsertRows,
- pThreadInfo->totalAffectedRows,
- (pThreadInfo->totalDelay)?
- (double)(pThreadInfo->totalAffectedRows/((double)pThreadInfo->totalDelay/1000000.0)):
- FLT_MAX);
-}
+#endif
// sync write interlace data
-static void* syncWriteInterlace(threadInfo *pThreadInfo) {
+static void* syncWriteInterlace(threadInfo *pThreadInfo, uint32_t interlaceRows) {
debugPrint("[%d] %s() LN%d: ### interlace write\n",
pThreadInfo->threadID, __func__, __LINE__);
int64_t insertRows;
- uint32_t interlaceRows;
uint64_t maxSqlLen;
int64_t nTimeStampStep;
uint64_t insert_interval;
@@ -7430,19 +8926,11 @@ static void* syncWriteInterlace(threadInfo *pThreadInfo) {
if (stbInfo) {
insertRows = stbInfo->insertRows;
-
- if ((stbInfo->interlaceRows == 0)
- && (g_args.interlace_rows > 0)) {
- interlaceRows = g_args.interlace_rows;
- } else {
- interlaceRows = stbInfo->interlaceRows;
- }
maxSqlLen = stbInfo->maxSqlLen;
nTimeStampStep = stbInfo->timeStampStep;
insert_interval = stbInfo->insertInterval;
} else {
- insertRows = g_args.num_of_DPT;
- interlaceRows = g_args.interlace_rows;
+ insertRows = g_args.insertRows;
maxSqlLen = g_args.max_sql_len;
nTimeStampStep = g_args.timestamp_step;
insert_interval = g_args.insert_interval;
@@ -7452,23 +8940,35 @@ static void* syncWriteInterlace(threadInfo *pThreadInfo) {
pThreadInfo->threadID, __func__, __LINE__,
pThreadInfo->start_table_from,
pThreadInfo->ntables, insertRows);
-
- if (interlaceRows > insertRows)
- interlaceRows = insertRows;
-
- if (interlaceRows > g_args.num_of_RPR)
- interlaceRows = g_args.num_of_RPR;
+#if 1
+ if (interlaceRows > g_args.reqPerReq)
+ interlaceRows = g_args.reqPerReq;
uint32_t batchPerTbl = interlaceRows;
uint32_t batchPerTblTimes;
if ((interlaceRows > 0) && (pThreadInfo->ntables > 1)) {
batchPerTblTimes =
- g_args.num_of_RPR / interlaceRows;
+ g_args.reqPerReq / interlaceRows;
} else {
batchPerTblTimes = 1;
}
+#else
+ uint32_t batchPerTbl;
+ if (interlaceRows > g_args.reqPerReq)
+ batchPerTbl = g_args.reqPerReq;
+ else
+ batchPerTbl = interlaceRows;
+
+ uint32_t batchPerTblTimes;
+ if ((interlaceRows > 0) && (pThreadInfo->ntables > 1)) {
+ batchPerTblTimes =
+ interlaceRows / batchPerTbl;
+ } else {
+ batchPerTblTimes = 1;
+ }
+#endif
pThreadInfo->buffer = calloc(maxSqlLen, 1);
if (NULL == pThreadInfo->buffer) {
errorPrint2( "%s() LN%d, Failed to alloc %"PRIu64" Bytes, reason:%s\n",
@@ -7501,6 +9001,7 @@ static void* syncWriteInterlace(threadInfo *pThreadInfo) {
st = taosGetTimestampMs();
flagSleep = false;
}
+
// generate data
memset(pThreadInfo->buffer, 0, maxSqlLen);
uint64_t remainderBufLen = maxSqlLen;
@@ -7514,6 +9015,7 @@ static void* syncWriteInterlace(threadInfo *pThreadInfo) {
uint32_t recOfBatch = 0;
+ int32_t generated;
for (uint64_t i = 0; i < batchPerTblTimes; i ++) {
char tableName[TSDB_TABLE_NAME_LEN];
@@ -7527,49 +9029,24 @@ static void* syncWriteInterlace(threadInfo *pThreadInfo) {
uint64_t oldRemainderLen = remainderBufLen;
- int32_t generated;
if (stbInfo) {
- if (stbInfo->iface == STMT_IFACE) {
- generated = prepareStbStmtWithSample(
- pThreadInfo,
- tableName,
- tableSeq,
- batchPerTbl,
- insertRows, 0,
- startTime,
- &(pThreadInfo->samplePos));
- } else {
- generated = generateStbInterlaceData(
- pThreadInfo,
- tableName, batchPerTbl, i,
- batchPerTblTimes,
- tableSeq,
- pstr,
- insertRows,
- startTime,
- &remainderBufLen);
- }
+ generated = generateStbInterlaceData(
+ pThreadInfo,
+ tableName, batchPerTbl, i,
+ batchPerTblTimes,
+ tableSeq,
+ pstr,
+ insertRows,
+ startTime,
+ &remainderBufLen);
} else {
- if (g_args.iface == STMT_IFACE) {
- debugPrint("[%d] %s() LN%d, tableName:%s, batch:%d startTime:%"PRId64"\n",
- pThreadInfo->threadID,
- __func__, __LINE__,
- tableName, batchPerTbl, startTime);
- generated = prepareStmtWithoutStb(
- pThreadInfo,
- tableName,
- batchPerTbl,
- insertRows, i,
- startTime);
- } else {
- generated = generateInterlaceDataWithoutStb(
- tableName, batchPerTbl,
- tableSeq,
- pThreadInfo->db_name, pstr,
- insertRows,
- startTime,
- &remainderBufLen);
- }
+ generated = generateInterlaceDataWithoutStb(
+ tableName, batchPerTbl,
+ tableSeq,
+ pThreadInfo->db_name, pstr,
+ insertRows,
+ startTime,
+ &remainderBufLen);
}
debugPrint("[%d] %s() LN%d, generated records is %d\n",
@@ -7608,7 +9085,7 @@ static void* syncWriteInterlace(threadInfo *pThreadInfo) {
if ((remainRows > 0) && (batchPerTbl > remainRows))
batchPerTbl = remainRows;
- if (pThreadInfo->ntables * batchPerTbl < g_args.num_of_RPR)
+ if (pThreadInfo->ntables * batchPerTbl < g_args.reqPerReq)
break;
}
@@ -7616,7 +9093,7 @@ static void* syncWriteInterlace(threadInfo *pThreadInfo) {
pThreadInfo->threadID, __func__, __LINE__,
generatedRecPerTbl, insertRows);
- if ((g_args.num_of_RPR - recOfBatch) < batchPerTbl)
+ if ((g_args.reqPerReq - recOfBatch) < batchPerTbl)
break;
}
@@ -7708,7 +9185,7 @@ static void* syncWriteProgressive(threadInfo *pThreadInfo) {
int64_t timeStampStep =
stbInfo?stbInfo->timeStampStep:g_args.timestamp_step;
int64_t insertRows =
- (stbInfo)?stbInfo->insertRows:g_args.num_of_DPT;
+ (stbInfo)?stbInfo->insertRows:g_args.insertRows;
verbosePrint("%s() LN%d insertRows=%"PRId64"\n",
__func__, __LINE__, insertRows);
@@ -7769,7 +9246,9 @@ static void* syncWriteProgressive(threadInfo *pThreadInfo) {
pThreadInfo,
tableName,
tableSeq,
- g_args.num_of_RPR,
+ (g_args.reqPerReq>stbInfo->insertRows)?
+ stbInfo->insertRows:
+ g_args.reqPerReq,
insertRows, i, start_time,
&(pThreadInfo->samplePos));
} else {
@@ -7786,7 +9265,7 @@ static void* syncWriteProgressive(threadInfo *pThreadInfo) {
generated = prepareStmtWithoutStb(
pThreadInfo,
tableName,
- g_args.num_of_RPR,
+ g_args.reqPerReq,
insertRows, i,
start_time);
} else {
@@ -7854,7 +9333,7 @@ static void* syncWriteProgressive(threadInfo *pThreadInfo) {
if (i >= insertRows)
break;
- } // num_of_DPT
+ } // insertRows
if ((g_args.verbose_print) &&
(tableSeq == pThreadInfo->ntables - 1) && (stbInfo)
@@ -7865,8 +9344,10 @@ static void* syncWriteProgressive(threadInfo *pThreadInfo) {
__func__, __LINE__, pThreadInfo->samplePos);
}
} // tableSeq
- if (percentComplete < 100)
+
+ if (percentComplete < 100) {
printf("[%d]:%d%%\n", pThreadInfo->threadID, percentComplete);
+ }
free_of_progressive:
tmfree(pThreadInfo->buffer);
@@ -7881,23 +9362,29 @@ static void* syncWrite(void *sarg) {
setThreadName("syncWrite");
- uint32_t interlaceRows;
+ uint32_t interlaceRows = 0;
if (stbInfo) {
- if ((stbInfo->interlaceRows == 0)
- && (g_args.interlace_rows > 0)) {
- interlaceRows = g_args.interlace_rows;
- } else {
+ if (stbInfo->interlaceRows < stbInfo->insertRows)
interlaceRows = stbInfo->interlaceRows;
- }
} else {
- interlaceRows = g_args.interlace_rows;
+ if (g_args.interlaceRows < g_args.insertRows)
+ interlaceRows = g_args.interlaceRows;
}
if (interlaceRows > 0) {
// interlace mode
- return syncWriteInterlace(pThreadInfo);
- } else {
+ if (((stbInfo) && (STMT_IFACE == stbInfo->iface))
+ || (STMT_IFACE == g_args.iface)) {
+#if STMT_BIND_PARAM_BATCH == 1
+ return syncWriteInterlaceStmtBatch(pThreadInfo, interlaceRows);
+#else
+ return syncWriteInterlaceStmt(pThreadInfo, interlaceRows);
+#endif
+ } else {
+ return syncWriteInterlace(pThreadInfo, interlaceRows);
+ }
+ }else {
// progressive mode
return syncWriteProgressive(pThreadInfo);
}
@@ -7919,11 +9406,11 @@ static void callBack(void *param, TAOS_RES *res, int code) {
char *buffer = calloc(1, pThreadInfo->stbInfo->maxSqlLen);
char data[MAX_DATA_SIZE];
char *pstr = buffer;
- pstr += sprintf(pstr, "insert into %s.%s%"PRId64" values",
+ pstr += sprintf(pstr, "INSERT INTO %s.%s%"PRId64" VALUES",
pThreadInfo->db_name, pThreadInfo->tb_prefix,
pThreadInfo->start_table_from);
// if (pThreadInfo->counter >= pThreadInfo->stbInfo->insertRows) {
- if (pThreadInfo->counter >= g_args.num_of_RPR) {
+ if (pThreadInfo->counter >= g_args.reqPerReq) {
pThreadInfo->start_table_from++;
pThreadInfo->counter = 0;
}
@@ -7934,7 +9421,7 @@ static void callBack(void *param, TAOS_RES *res, int code) {
return;
}
- for (int i = 0; i < g_args.num_of_RPR; i++) {
+ for (int i = 0; i < g_args.reqPerReq; i++) {
int rand_num = taosRandom() % 100;
if (0 != pThreadInfo->stbInfo->disorderRatio
&& rand_num < pThreadInfo->stbInfo->disorderRatio) {
@@ -8014,81 +9501,6 @@ static int convertHostToServAddr(char *host, uint16_t port, struct sockaddr_in *
return 0;
}
-static int parseSampleFileToStmt(
- threadInfo *pThreadInfo,
- SSuperTable *stbInfo, uint32_t timePrec)
-{
- pThreadInfo->sampleBindArray =
- calloc(1, sizeof(char *) * MAX_SAMPLES_ONCE_FROM_FILE);
- if (pThreadInfo->sampleBindArray == NULL) {
- errorPrint2("%s() LN%d, Failed to allocate %"PRIu64" bind array buffer\n",
- __func__, __LINE__,
- (uint64_t)sizeof(char *) * MAX_SAMPLES_ONCE_FROM_FILE);
- return -1;
- }
-
- for (int i=0; i < MAX_SAMPLES_ONCE_FROM_FILE; i++) {
- char *bindArray =
- calloc(1, sizeof(TAOS_BIND) * (stbInfo->columnCount + 1));
- if (bindArray == NULL) {
- errorPrint2("%s() LN%d, Failed to allocate %d bind params\n",
- __func__, __LINE__, (stbInfo->columnCount + 1));
- return -1;
- }
-
- TAOS_BIND *bind;
- int cursor = 0;
-
- for (int c = 0; c < stbInfo->columnCount + 1; c++) {
- bind = (TAOS_BIND *)((char *)bindArray + (sizeof(TAOS_BIND) * c));
-
- if (c == 0) {
- bind->buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
- bind->buffer_length = sizeof(int64_t);
- bind->buffer = NULL; //bind_ts;
- bind->length = &bind->buffer_length;
- bind->is_null = NULL;
- } else {
- char *restStr = stbInfo->sampleDataBuf
- + stbInfo->lenOfOneRow * i + cursor;
- int lengthOfRest = strlen(restStr);
-
- int index = 0;
- for (index = 0; index < lengthOfRest; index ++) {
- if (restStr[index] == ',') {
- break;
- }
- }
-
- char *bindBuffer = calloc(1, index + 1);
- if (bindBuffer == NULL) {
- errorPrint2("%s() LN%d, Failed to allocate %d bind buffer\n",
- __func__, __LINE__, DOUBLE_BUFF_LEN);
- return -1;
- }
-
- strncpy(bindBuffer, restStr, index);
- cursor += index + 1; // skip ',' too
-
- if (-1 == prepareStmtBindArrayByType(
- bind,
- stbInfo->columns[c-1].dataType,
- stbInfo->columns[c-1].dataLen,
- timePrec,
- bindBuffer)) {
- free(bindBuffer);
- return -1;
- }
- free(bindBuffer);
- }
- }
- *((uintptr_t *)(pThreadInfo->sampleBindArray + (sizeof(char *)) * i)) =
- (uintptr_t)bindArray;
- }
-
- return 0;
-}
-
static void startMultiThreadInsertData(int threads, char* db_name,
char* precision, SSuperTable* stbInfo) {
@@ -8126,12 +9538,17 @@ static void startMultiThreadInsertData(int threads, char* db_name,
__func__, __LINE__, start_time);
// read sample data from file first
+ int ret;
if (stbInfo) {
- if (0 != prepareSampleDataForSTable(stbInfo)) {
- errorPrint2("%s() LN%d, prepare sample data for stable failed!\n",
- __func__, __LINE__);
- exit(EXIT_FAILURE);
- }
+ ret = prepareSampleForStb(stbInfo);
+ } else {
+ ret = prepareSampleForNtb();
+ }
+
+ if (0 != ret) {
+ errorPrint2("%s() LN%d, prepare sample data for stable failed!\n",
+ __func__, __LINE__);
+ exit(EXIT_FAILURE);
}
TAOS* taos0 = taos_connect(
@@ -8162,6 +9579,12 @@ static void startMultiThreadInsertData(int threads, char* db_name,
|| ((stbInfo->childTblOffset
+ stbInfo->childTblLimit)
> (stbInfo->childTblCount))) {
+
+ if (stbInfo->childTblCount < stbInfo->childTblOffset) {
+ printf("WARNING: offset will not be used since the child tables count is less then offset!\n");
+
+ stbInfo->childTblOffset = 0;
+ }
stbInfo->childTblLimit =
stbInfo->childTblCount - stbInfo->childTblOffset;
}
@@ -8200,12 +9623,13 @@ static void startMultiThreadInsertData(int threads, char* db_name,
int64_t childTblCount;
getChildNameOfSuperTableWithLimitAndOffset(
taos0,
- db_name, stbInfo->sTblName,
+ db_name, stbInfo->stbName,
&stbInfo->childTblName, &childTblCount,
limit,
offset);
+ ntables = childTblCount; // CBD
} else {
- ntables = g_args.num_of_tables;
+ ntables = g_args.ntables;
tableFrom = 0;
}
@@ -8241,6 +9665,38 @@ static void startMultiThreadInsertData(int threads, char* db_name,
char *stmtBuffer = calloc(1, BUFFER_SIZE);
assert(stmtBuffer);
+
+#if STMT_BIND_PARAM_BATCH == 1
+ uint32_t interlaceRows = 0;
+ uint32_t batch;
+
+ if (stbInfo) {
+ if ((stbInfo->interlaceRows == 0)
+ && (g_args.interlaceRows > 0)
+ ) {
+ interlaceRows = g_args.interlaceRows;
+
+ } else {
+ interlaceRows = stbInfo->interlaceRows;
+ }
+
+ if (interlaceRows > stbInfo->insertRows) {
+ interlaceRows = 0;
+ }
+ } else {
+ if (g_args.interlaceRows < g_args.insertRows)
+ interlaceRows = g_args.interlaceRows;
+ }
+
+ if (interlaceRows > 0) {
+ batch = interlaceRows;
+ } else {
+ batch = (g_args.reqPerReq>g_args.insertRows)?
+ g_args.insertRows:g_args.reqPerReq;
+ }
+
+#endif
+
if ((g_args.iface == STMT_IFACE)
|| ((stbInfo)
&& (stbInfo->iface == STMT_IFACE))) {
@@ -8250,7 +9706,7 @@ static void startMultiThreadInsertData(int threads, char* db_name,
&& (AUTO_CREATE_SUBTBL
== stbInfo->autoCreateTable)) {
pstr += sprintf(pstr, "INSERT INTO ? USING %s TAGS(?",
- stbInfo->sTblName);
+ stbInfo->stbName);
for (int tag = 0; tag < (stbInfo->tagCount - 1);
tag ++ ) {
pstr += sprintf(pstr, ",?");
@@ -8260,12 +9716,9 @@ static void startMultiThreadInsertData(int threads, char* db_name,
pstr += sprintf(pstr, "INSERT INTO ? VALUES(?");
}
- int columnCount;
- if (stbInfo) {
- columnCount = stbInfo->columnCount;
- } else {
- columnCount = g_args.num_of_CPR;
- }
+ int columnCount = (stbInfo)?
+ stbInfo->columnCount:
+ g_args.columnCount;
for (int col = 0; col < columnCount; col ++) {
pstr += sprintf(pstr, ",?");
@@ -8273,6 +9726,9 @@ static void startMultiThreadInsertData(int threads, char* db_name,
pstr += sprintf(pstr, ")");
debugPrint("%s() LN%d, stmtBuffer: %s", __func__, __LINE__, stmtBuffer);
+#if STMT_BIND_PARAM_BATCH == 1
+ parseSamplefileToStmtBatch(stbInfo);
+#endif
}
for (int i = 0; i < threads; i++) {
@@ -8316,8 +9772,7 @@ static void startMultiThreadInsertData(int threads, char* db_name,
exit(EXIT_FAILURE);
}
- int ret = taos_stmt_prepare(pThreadInfo->stmt, stmtBuffer, 0);
- if (ret != 0) {
+ if (0 != taos_stmt_prepare(pThreadInfo->stmt, stmtBuffer, 0)) {
free(pids);
free(infos);
free(stmtBuffer);
@@ -8328,7 +9783,19 @@ static void startMultiThreadInsertData(int threads, char* db_name,
pThreadInfo->bind_ts = malloc(sizeof(int64_t));
if (stbInfo) {
- parseSampleFileToStmt(pThreadInfo, stbInfo, timePrec);
+#if STMT_BIND_PARAM_BATCH == 1
+ parseStbSampleToStmtBatchForThread(
+ pThreadInfo, stbInfo, timePrec, batch);
+#else
+ parseStbSampleToStmt(pThreadInfo, stbInfo, timePrec);
+#endif
+ } else {
+#if STMT_BIND_PARAM_BATCH == 1
+ parseNtbSampleToStmtBatchForThread(
+ pThreadInfo, timePrec, batch);
+#else
+ parseNtbSampleToStmt(pThreadInfo, timePrec);
+#endif
}
}
} else {
@@ -8373,19 +9840,28 @@ static void startMultiThreadInsertData(int threads, char* db_name,
for (int i = 0; i < threads; i++) {
threadInfo *pThreadInfo = infos + i;
+ tsem_destroy(&(pThreadInfo->lock_sem));
+ taos_close(pThreadInfo->taos);
+
if (pThreadInfo->stmt) {
taos_stmt_close(pThreadInfo->stmt);
- tmfree((char *)pThreadInfo->bind_ts);
}
- tsem_destroy(&(pThreadInfo->lock_sem));
- taos_close(pThreadInfo->taos);
+ tmfree((char *)pThreadInfo->bind_ts);
+#if STMT_BIND_PARAM_BATCH == 1
+ tmfree((char *)pThreadInfo->bind_ts_array);
+ tmfree(pThreadInfo->bindParams);
+ tmfree(pThreadInfo->is_null);
+#else
if (pThreadInfo->sampleBindArray) {
- for (int k = 0; k < MAX_SAMPLES_ONCE_FROM_FILE; k++) {
+ for (int k = 0; k < MAX_SAMPLES; k++) {
uintptr_t *tmp = (uintptr_t *)(*(uintptr_t *)(
pThreadInfo->sampleBindArray
+ sizeof(uintptr_t *) * k));
- for (int c = 1; c < pThreadInfo->stbInfo->columnCount + 1; c++) {
+ int columnCount = (pThreadInfo->stbInfo)?
+ pThreadInfo->stbInfo->columnCount:
+ g_args.columnCount;
+ for (int c = 1; c < columnCount + 1; c++) {
TAOS_BIND *bind = (TAOS_BIND *)((char *)tmp + (sizeof(TAOS_BIND) * c));
if (bind)
tmfree(bind->buffer);
@@ -8394,6 +9870,7 @@ static void startMultiThreadInsertData(int threads, char* db_name,
}
tmfree(pThreadInfo->sampleBindArray);
}
+#endif
debugPrint("%s() LN%d, [%d] totalInsert=%"PRIu64" totalAffected=%"PRIu64"\n",
__func__, __LINE__,
@@ -8412,7 +9889,6 @@ static void startMultiThreadInsertData(int threads, char* db_name,
if (pThreadInfo->maxDelay > maxDelay) maxDelay = pThreadInfo->maxDelay;
if (pThreadInfo->minDelay < minDelay) minDelay = pThreadInfo->minDelay;
}
- cntDelay -= 1;
if (cntDelay == 0) cntDelay = 1;
avgDelay = (double)totalDelay / cntDelay;
@@ -8427,7 +9903,7 @@ static void startMultiThreadInsertData(int threads, char* db_name,
fprintf(stderr, "Spent %.4f seconds to insert rows: %"PRIu64", affected rows: %"PRIu64" with %d thread(s) into %s.%s. %.2f records/second\n\n",
tInMs, stbInfo->totalInsertRows,
stbInfo->totalAffectedRows,
- threads, db_name, stbInfo->sTblName,
+ threads, db_name, stbInfo->stbName,
(double)(stbInfo->totalInsertRows/tInMs));
if (g_fpOfInsertResult) {
@@ -8435,7 +9911,7 @@ static void startMultiThreadInsertData(int threads, char* db_name,
"Spent %.4f seconds to insert rows: %"PRIu64", affected rows: %"PRIu64" with %d thread(s) into %s.%s. %.2f records/second\n\n",
tInMs, stbInfo->totalInsertRows,
stbInfo->totalAffectedRows,
- threads, db_name, stbInfo->sTblName,
+ threads, db_name, stbInfo->stbName,
(double)(stbInfo->totalInsertRows/tInMs));
}
} else {
@@ -8488,16 +9964,16 @@ static void *readTable(void *sarg) {
return NULL;
}
- int64_t num_of_DPT;
+ int64_t insertRows;
/* if (pThreadInfo->stbInfo) {
- num_of_DPT = pThreadInfo->stbInfo->insertRows; // nrecords_per_table;
+ insertRows = pThreadInfo->stbInfo->insertRows; // nrecords_per_table;
} else {
*/
- num_of_DPT = g_args.num_of_DPT;
+ insertRows = g_args.insertRows;
// }
- int64_t num_of_tables = pThreadInfo->ntables; // rinfo->end_table_to - rinfo->start_table_from + 1;
- int64_t totalData = num_of_DPT * num_of_tables;
+ int64_t ntables = pThreadInfo->ntables; // pThreadInfo->end_table_to - pThreadInfo->start_table_from + 1;
+ int64_t totalData = insertRows * ntables;
bool do_aggreFunc = g_Dbs.do_aggreFunc;
int n = do_aggreFunc ? (sizeof(g_aggreFunc) / sizeof(g_aggreFunc[0])) : 2;
@@ -8510,8 +9986,8 @@ static void *readTable(void *sarg) {
for (int j = 0; j < n; j++) {
double totalT = 0;
uint64_t count = 0;
- for (int64_t i = 0; i < num_of_tables; i++) {
- sprintf(command, "select %s from %s%"PRId64" where ts>= %" PRIu64,
+ for (int64_t i = 0; i < ntables; i++) {
+ sprintf(command, "SELECT %s FROM %s%"PRId64" WHERE ts>= %" PRIu64,
g_aggreFunc[j], tb_prefix, i, sTime);
double t = taosGetTimestampMs();
@@ -8539,7 +10015,7 @@ static void *readTable(void *sarg) {
fprintf(fp, "|%10s | %"PRId64" | %12.2f | %10.2f |\n",
g_aggreFunc[j][0] == '*' ? " * " : g_aggreFunc[j], totalData,
- (double)(num_of_tables * num_of_DPT) / totalT, totalT * 1000);
+ (double)(ntables * insertRows) / totalT, totalT * 1000);
printf("select %10s took %.6f second(s)\n", g_aggreFunc[j], totalT * 1000);
}
fprintf(fp, "\n");
@@ -8564,9 +10040,9 @@ static void *readMetric(void *sarg) {
return NULL;
}
- int64_t num_of_DPT = pThreadInfo->stbInfo->insertRows;
- int64_t num_of_tables = pThreadInfo->ntables; // rinfo->end_table_to - rinfo->start_table_from + 1;
- int64_t totalData = num_of_DPT * num_of_tables;
+ int64_t insertRows = pThreadInfo->stbInfo->insertRows;
+ int64_t ntables = pThreadInfo->ntables; // pThreadInfo->end_table_to - pThreadInfo->start_table_from + 1;
+ int64_t totalData = insertRows * ntables;
bool do_aggreFunc = g_Dbs.do_aggreFunc;
int n = do_aggreFunc ? (sizeof(g_aggreFunc) / sizeof(g_aggreFunc[0])) : 2;
@@ -8580,7 +10056,7 @@ static void *readMetric(void *sarg) {
char condition[COND_BUF_LEN] = "\0";
char tempS[64] = "\0";
- int64_t m = 10 < num_of_tables ? 10 : num_of_tables;
+ int64_t m = 10 < ntables ? 10 : ntables;
for (int64_t i = 1; i <= m; i++) {
if (i == 1) {
@@ -8590,7 +10066,7 @@ static void *readMetric(void *sarg) {
}
strncat(condition, tempS, COND_BUF_LEN - 1);
- sprintf(command, "select %s from meters where %s", g_aggreFunc[j], condition);
+ sprintf(command, "SELECT %s FROM meters WHERE %s", g_aggreFunc[j], condition);
printf("Where condition: %s\n", condition);
fprintf(fp, "%s\n", command);
@@ -8615,7 +10091,7 @@ static void *readMetric(void *sarg) {
t = taosGetTimestampMs() - t;
fprintf(fp, "| Speed: %12.2f(per s) | Latency: %.4f(ms) |\n",
- num_of_tables * num_of_DPT / (t * 1000.0), t);
+ ntables * insertRows / (t * 1000.0), t);
printf("select %10s took %.6f second(s)\n\n", g_aggreFunc[j], t * 1000.0);
taos_free_result(pSql);
@@ -8671,7 +10147,7 @@ static int insertTestProcess() {
}
free(cmdBuffer);
- // pretreatement
+ // pretreatment
if (prepareSampleData() != 0) {
if (g_fpOfInsertResult)
fclose(g_fpOfInsertResult);
@@ -8948,7 +10424,7 @@ static int queryTestProcess() {
if (0 != g_queryInfo.superQueryInfo.sqlCount) {
getAllChildNameOfSuperTable(taos,
g_queryInfo.dbName,
- g_queryInfo.superQueryInfo.sTblName,
+ g_queryInfo.superQueryInfo.stbName,
&g_queryInfo.superQueryInfo.childTblName,
&g_queryInfo.superQueryInfo.childTblCount);
}
@@ -9004,7 +10480,7 @@ static int queryTestProcess() {
}
}
- pThreadInfo->taos = NULL;// TODO: workaround to use separate taos connection;
+ pThreadInfo->taos = NULL;// workaround to use separate taos connection;
pthread_create(pids + seq, NULL, specifiedTableQuery,
pThreadInfo);
@@ -9054,7 +10530,7 @@ static int queryTestProcess() {
pThreadInfo->ntables = iend_table_to = i < b ? tableFrom + a : tableFrom + a - 1;
tableFrom = pThreadInfo->end_table_to + 1;
- pThreadInfo->taos = NULL; // TODO: workaround to use separate taos connection;
+ pThreadInfo->taos = NULL; // workaround to use separate taos connection;
pthread_create(pidsOfSub + i, NULL, superTableQuery, pThreadInfo);
}
@@ -9081,7 +10557,7 @@ static int queryTestProcess() {
tmfree((char*)pidsOfSub);
tmfree((char*)infosOfSub);
- // taos_close(taos);// TODO: workaround to use separate taos connection;
+ // taos_close(taos);// workaround to use separate taos connection;
uint64_t endTs = taosGetTimestampMs();
uint64_t totalQueried = g_queryInfo.specifiedQueryInfo.totalQueried +
@@ -9103,7 +10579,7 @@ static void stable_sub_callback(
if (param)
fetchResult(res, (threadInfo *)param);
- // tao_unscribe() will free result.
+ // tao_unsubscribe() will free result.
}
static void specified_sub_callback(
@@ -9116,7 +10592,7 @@ static void specified_sub_callback(
if (param)
fetchResult(res, (threadInfo *)param);
- // tao_unscribe() will free result.
+ // tao_unsubscribe() will free result.
}
static TAOS_SUB* subscribeImpl(
@@ -9441,12 +10917,12 @@ static int subscribeTestProcess() {
if (0 != g_queryInfo.superQueryInfo.sqlCount) {
getAllChildNameOfSuperTable(taos,
g_queryInfo.dbName,
- g_queryInfo.superQueryInfo.sTblName,
+ g_queryInfo.superQueryInfo.stbName,
&g_queryInfo.superQueryInfo.childTblName,
&g_queryInfo.superQueryInfo.childTblCount);
}
- taos_close(taos); // TODO: workaround to use separate taos connection;
+ taos_close(taos); // workaround to use separate taos connection;
pthread_t *pids = NULL;
threadInfo *infos = NULL;
@@ -9456,12 +10932,12 @@ static int subscribeTestProcess() {
//==== create threads for query for specified table
if (g_queryInfo.specifiedQueryInfo.sqlCount <= 0) {
- debugPrint("%s() LN%d, sepcified query sqlCount %d.\n",
+ debugPrint("%s() LN%d, specified query sqlCount %d.\n",
__func__, __LINE__,
g_queryInfo.specifiedQueryInfo.sqlCount);
} else {
if (g_queryInfo.specifiedQueryInfo.concurrent <= 0) {
- errorPrint2("%s() LN%d, sepcified query sqlCount %d.\n",
+ errorPrint2("%s() LN%d, specified query sqlCount %d.\n",
__func__, __LINE__,
g_queryInfo.specifiedQueryInfo.sqlCount);
exit(EXIT_FAILURE);
@@ -9488,7 +10964,7 @@ static int subscribeTestProcess() {
threadInfo *pThreadInfo = infos + seq;
pThreadInfo->threadID = seq;
pThreadInfo->querySeq = i;
- pThreadInfo->taos = NULL; // TODO: workaround to use separate taos connection;
+ pThreadInfo->taos = NULL; // workaround to use separate taos connection;
pthread_create(pids + seq, NULL, specifiedSubscribe, pThreadInfo);
}
}
@@ -9545,7 +11021,7 @@ static int subscribeTestProcess() {
pThreadInfo->ntables = jend_table_to = jend_table_to + 1;
- pThreadInfo->taos = NULL; // TODO: workaround to use separate taos connection;
+ pThreadInfo->taos = NULL; // workaround to use separate taos connection;
pthread_create(pidsOfStable + seq,
NULL, superSubscribe, pThreadInfo);
}
@@ -9618,8 +11094,8 @@ static void setParaFromArg() {
g_Dbs.port = g_args.port;
}
- g_Dbs.threadCount = g_args.num_of_threads;
- g_Dbs.threadCountForCreateTbl = g_args.num_of_threads;
+ g_Dbs.threadCount = g_args.nthreads;
+ g_Dbs.threadCountForCreateTbl = g_args.nthreads;
g_Dbs.dbCount = 1;
g_Dbs.db[0].drop = true;
@@ -9636,22 +11112,23 @@ static void setParaFromArg() {
g_Dbs.do_aggreFunc = true;
char dataString[TSDB_MAX_BYTES_PER_ROW];
- char **data_type = g_args.datatype;
+ char *data_type = g_args.data_type;
+ char **dataType = g_args.dataType;
memset(dataString, 0, TSDB_MAX_BYTES_PER_ROW);
- if (strcasecmp(data_type[0], "BINARY") == 0
- || strcasecmp(data_type[0], "BOOL") == 0
- || strcasecmp(data_type[0], "NCHAR") == 0 ) {
+ if ((data_type[0] == TSDB_DATA_TYPE_BINARY)
+ || (data_type[0] == TSDB_DATA_TYPE_BOOL)
+ || (data_type[0] == TSDB_DATA_TYPE_NCHAR)) {
g_Dbs.do_aggreFunc = false;
}
if (g_args.use_metric) {
g_Dbs.db[0].superTblCount = 1;
- tstrncpy(g_Dbs.db[0].superTbls[0].sTblName, "meters", TSDB_TABLE_NAME_LEN);
- g_Dbs.db[0].superTbls[0].childTblCount = g_args.num_of_tables;
- g_Dbs.threadCount = g_args.num_of_threads;
- g_Dbs.threadCountForCreateTbl = g_args.num_of_threads;
+ tstrncpy(g_Dbs.db[0].superTbls[0].stbName, "meters", TSDB_TABLE_NAME_LEN);
+ g_Dbs.db[0].superTbls[0].childTblCount = g_args.ntables;
+ g_Dbs.threadCount = g_args.nthreads;
+ g_Dbs.threadCountForCreateTbl = g_args.nthreads;
g_Dbs.asyncMode = g_args.async_mode;
g_Dbs.db[0].superTbls[0].autoCreateTable = PRE_CREATE_SUBTBL;
@@ -9671,26 +11148,28 @@ static void setParaFromArg() {
"2017-07-14 10:40:00.000", MAX_TB_NAME_SIZE);
g_Dbs.db[0].superTbls[0].timeStampStep = g_args.timestamp_step;
- g_Dbs.db[0].superTbls[0].insertRows = g_args.num_of_DPT;
+ g_Dbs.db[0].superTbls[0].insertRows = g_args.insertRows;
g_Dbs.db[0].superTbls[0].maxSqlLen = g_args.max_sql_len;
g_Dbs.db[0].superTbls[0].columnCount = 0;
for (int i = 0; i < MAX_NUM_COLUMNS; i++) {
- if (data_type[i] == NULL) {
+ if (data_type[i] == TSDB_DATA_TYPE_NULL) {
break;
}
+ g_Dbs.db[0].superTbls[0].columns[i].data_type = data_type[i];
tstrncpy(g_Dbs.db[0].superTbls[0].columns[i].dataType,
- data_type[i], min(DATATYPE_BUFF_LEN, strlen(data_type[i]) + 1));
+ dataType[i], min(DATATYPE_BUFF_LEN, strlen(dataType[i]) + 1));
g_Dbs.db[0].superTbls[0].columns[i].dataLen = g_args.binwidth;
g_Dbs.db[0].superTbls[0].columnCount++;
}
- if (g_Dbs.db[0].superTbls[0].columnCount > g_args.num_of_CPR) {
- g_Dbs.db[0].superTbls[0].columnCount = g_args.num_of_CPR;
+ if (g_Dbs.db[0].superTbls[0].columnCount > g_args.columnCount) {
+ g_Dbs.db[0].superTbls[0].columnCount = g_args.columnCount;
} else {
for (int i = g_Dbs.db[0].superTbls[0].columnCount;
- i < g_args.num_of_CPR; i++) {
+ i < g_args.columnCount; i++) {
+ g_Dbs.db[0].superTbls[0].columns[i].data_type = TSDB_DATA_TYPE_INT;
tstrncpy(g_Dbs.db[0].superTbls[0].columns[i].dataType,
"INT", min(DATATYPE_BUFF_LEN, strlen("INT") + 1));
g_Dbs.db[0].superTbls[0].columns[i].dataLen = 0;
@@ -9707,7 +11186,7 @@ static void setParaFromArg() {
g_Dbs.db[0].superTbls[0].tags[1].dataLen = g_args.binwidth;
g_Dbs.db[0].superTbls[0].tagCount = 2;
} else {
- g_Dbs.threadCountForCreateTbl = g_args.num_of_threads;
+ g_Dbs.threadCountForCreateTbl = g_args.nthreads;
g_Dbs.db[0].superTbls[0].tagCount = 0;
}
}
@@ -9840,8 +11319,8 @@ static void queryResult() {
tstrncpy(pThreadInfo->tb_prefix,
g_Dbs.db[0].superTbls[0].childTblPrefix, TBNAME_PREFIX_LEN);
} else {
- pThreadInfo->ntables = g_args.num_of_tables;
- pThreadInfo->end_table_to = g_args.num_of_tables -1;
+ pThreadInfo->ntables = g_args.ntables;
+ pThreadInfo->end_table_to = g_args.ntables -1;
tstrncpy(pThreadInfo->tb_prefix, g_args.tb_prefix, TSDB_TABLE_NAME_LEN);
}
diff --git a/src/kit/taosdump/taosdump.c b/src/kit/taosdump/taosdump.c
index ae2193a82eb447f0e948abc1757c21cab46ccf34..fe7616fa174f5af707892cf3d251689a60111ed6 100644
--- a/src/kit/taosdump/taosdump.c
+++ b/src/kit/taosdump/taosdump.c
@@ -1209,14 +1209,14 @@ _dump_db_point:
fprintf(fp, "USE %s;\n\n", g_dbInfos[0]->name);
- int32_t totalNumOfThread = 1; // 0: all normal talbe into .tables.tmp.0
+ int32_t totalNumOfThread = 1; // 0: all normal table into .tables.tmp.0
int normalTblFd = -1;
int32_t retCode;
int superTblCnt = 0 ;
for (int i = 1; g_args.arg_list[i]; i++) {
if (taosGetTableRecordInfo(g_args.arg_list[i],
&tableRecordInfo, taos) < 0) {
- errorPrint("input the invalide table %s\n",
+ errorPrint("input the invalid table %s\n",
g_args.arg_list[i]);
continue;
}
@@ -1341,11 +1341,10 @@ static int taosGetTableDes(
return count;
}
- // if chidl-table have tag, using select tagName from table to get tagValue
+ // if child-table have tag, using select tagName from table to get tagValue
for (int i = 0 ; i < count; i++) {
if (strcmp(stableDes->cols[i].note, "TAG") != 0) continue;
-
sprintf(sqlstr, "select %s from %s.%s",
stableDes->cols[i].field, dbName, table);
@@ -2443,7 +2442,7 @@ static int taosGetFilesNum(const char *directoryName,
}
if (fileNum <= 0) {
- errorPrint("directory:%s is empry\n", directoryName);
+ errorPrint("directory:%s is empty\n", directoryName);
exit(-1);
}
@@ -2620,9 +2619,9 @@ static int taosDumpInOneFile(TAOS* taos, FILE* fp, char* fcharset,
memcpy(cmd + cmd_len, line, read_len);
cmd[read_len + cmd_len]= '\0';
if (queryDbImpl(taos, cmd)) {
- errorPrint("%s() LN%d, error sql: linenu:%d, file:%s\n",
+ errorPrint("%s() LN%d, error sql: lineno:%d, file:%s\n",
__func__, __LINE__, lineNo, fileName);
- fprintf(g_fpOfResult, "error sql: linenu:%d, file:%s\n", lineNo, fileName);
+ fprintf(g_fpOfResult, "error sql: lineno:%d, file:%s\n", lineNo, fileName);
}
memset(cmd, 0, TSDB_MAX_ALLOWED_SQL_LEN);
diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c
index 68529ab8a240c2313ae9417bef9f4112759b0c9f..a6158906a7cc77b57244594fe51881e5df0b68c8 100644
--- a/src/mnode/src/mnodeTable.c
+++ b/src/mnode/src/mnodeTable.c
@@ -1231,7 +1231,9 @@ static int32_t mnodeAddSuperTableTagCb(SMnodeMsg *pMsg, int32_t code) {
SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
mLInfo("msg:%p, app:%p stable %s, add tag result:%s, numOfTags:%d", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
tstrerror(code), pStable->numOfTags);
-
+ if (code == TSDB_CODE_SUCCESS) {
+ code = mnodeGetSuperTableMeta(pMsg);
+ }
return code;
}
@@ -1287,6 +1289,9 @@ static int32_t mnodeDropSuperTableTagCb(SMnodeMsg *pMsg, int32_t code) {
SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
mLInfo("msg:%p, app:%p stable %s, drop tag result:%s", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
tstrerror(code));
+ if (code == TSDB_CODE_SUCCESS) {
+ code = mnodeGetSuperTableMeta(pMsg);
+ }
return code;
}
@@ -1321,6 +1326,9 @@ static int32_t mnodeModifySuperTableTagNameCb(SMnodeMsg *pMsg, int32_t code) {
SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
mLInfo("msg:%p, app:%p stable %s, modify tag result:%s", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
tstrerror(code));
+ if (code == TSDB_CODE_SUCCESS) {
+ code = mnodeGetSuperTableMeta(pMsg);
+ }
return code;
}
@@ -1376,6 +1384,9 @@ static int32_t mnodeAddSuperTableColumnCb(SMnodeMsg *pMsg, int32_t code) {
SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
mLInfo("msg:%p, app:%p stable %s, add column result:%s", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
tstrerror(code));
+ if (code == TSDB_CODE_SUCCESS) {
+ code = mnodeGetSuperTableMeta(pMsg);
+ }
return code;
}
@@ -1444,6 +1455,9 @@ static int32_t mnodeDropSuperTableColumnCb(SMnodeMsg *pMsg, int32_t code) {
SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
mLInfo("msg:%p, app:%p stable %s, delete column result:%s", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
tstrerror(code));
+ if (code == TSDB_CODE_SUCCESS) {
+ code = mnodeGetSuperTableMeta(pMsg);
+ }
return code;
}
@@ -1489,6 +1503,9 @@ static int32_t mnodeChangeSuperTableColumnCb(SMnodeMsg *pMsg, int32_t code) {
SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
mLInfo("msg:%p, app:%p stable %s, change column result:%s", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
tstrerror(code));
+ if (code == TSDB_CODE_SUCCESS) {
+ code = mnodeGetSuperTableMeta(pMsg);
+ }
return code;
}
diff --git a/src/os/src/darwin/darwinSystem.c b/src/os/src/darwin/darwinSystem.c
index 6f296c9fef4f8db5249e90892214c3b928873939..f152e36d7b9f41e5ddf97db3f5d0c4cf2d714632 100644
--- a/src/os/src/darwin/darwinSystem.c
+++ b/src/os/src/darwin/darwinSystem.c
@@ -31,7 +31,6 @@ void taosCloseDll(void *handle) {
int taosSetConsoleEcho(bool on)
{
-#if 0
#define ECHOFLAGS (ECHO | ECHOE | ECHOK | ECHONL)
int err;
struct termios term;
@@ -52,7 +51,6 @@ int taosSetConsoleEcho(bool on)
return -1;
}
-#endif
return 0;
}
diff --git a/src/plugins/http/inc/httpInt.h b/src/plugins/http/inc/httpInt.h
index 99a5b770aa140df0d0c5787091cb8950ae6dd25f..6c567e23bc817957d7f376ef101f8e5ca88559e6 100644
--- a/src/plugins/http/inc/httpInt.h
+++ b/src/plugins/http/inc/httpInt.h
@@ -147,6 +147,7 @@ typedef struct HttpContext {
int32_t state;
uint8_t reqType;
uint8_t parsed;
+ uint8_t error;
char ipstr[22];
char user[TSDB_USER_LEN]; // parsed from auth token or login message
char pass[HTTP_PASSWORD_LEN];
diff --git a/src/plugins/http/src/httpContext.c b/src/plugins/http/src/httpContext.c
index 51adef11b9af3ebb83537024edbb3ba369aaeb03..11945453c56ab7fdd1fc8b0c4f2510bbbdda1a6e 100644
--- a/src/plugins/http/src/httpContext.c
+++ b/src/plugins/http/src/httpContext.c
@@ -188,11 +188,12 @@ void httpCloseContextByApp(HttpContext *pContext) {
pContext->parsed = false;
bool keepAlive = true;
- if (parser && parser->httpVersion == HTTP_VERSION_10 && parser->keepAlive != HTTP_KEEPALIVE_ENABLE) {
+ if (pContext->error == true) {
+ keepAlive = false;
+ } else if (parser && parser->httpVersion == HTTP_VERSION_10 && parser->keepAlive != HTTP_KEEPALIVE_ENABLE) {
keepAlive = false;
} else if (parser && parser->httpVersion != HTTP_VERSION_10 && parser->keepAlive == HTTP_KEEPALIVE_DISABLE) {
keepAlive = false;
- } else {
}
if (keepAlive) {
diff --git a/src/plugins/http/src/httpParser.c b/src/plugins/http/src/httpParser.c
index 02f21037b8592cc847f02f1b2fbe3c01acd508d8..62b1737f6fe7128ee132727b2870fca5f62b737a 100644
--- a/src/plugins/http/src/httpParser.c
+++ b/src/plugins/http/src/httpParser.c
@@ -663,7 +663,7 @@ static int32_t httpParserOnTarget(HttpParser *parser, HTTP_PARSER_STATE state, c
HttpContext *pContext = parser->pContext;
int32_t ok = 0;
do {
- if (!isspace(c) && c != '\r' && c != '\n') {
+ if (!isspace(c)) {
if (httpAppendString(&parser->str, &c, 1)) {
httpError("context:%p, fd:%d, parser state:%d, char:[%c]%02x, oom", pContext, pContext->fd, state, c, c);
ok = -1;
@@ -1157,6 +1157,10 @@ static int32_t httpParseChar(HttpParser *parser, const char c, int32_t *again) {
httpOnError(parser, HTTP_CODE_INTERNAL_SERVER_ERROR, TSDB_CODE_HTTP_PARSE_ERROR_STATE);
}
+ if (ok != 0) {
+ pContext->error = true;
+ }
+
return ok;
}
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index cf5142d359e4730db125a1a720643d5c163e37ec..54a5423219c8822e42c20a1d9a0d392913f8fdef 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -2402,11 +2402,11 @@ bool isQueryKilled(SQInfo *pQInfo) {
// query has been executed more than tsShellActivityTimer, and the retrieve has not arrived
// abort current query execution.
- if (pQInfo->owner != 0 && ((taosGetTimestampSec() - pQInfo->startExecTs) > getMaximumIdleDurationSec()) &&
+ if (pQInfo->owner != 0 && ((taosGetTimestampSec() - pQInfo->startExecTs/1000) > getMaximumIdleDurationSec()) &&
(!needBuildResAfterQueryComplete(pQInfo))) {
assert(pQInfo->startExecTs != 0);
- qDebug("QInfo:%" PRIu64 " retrieve not arrive beyond %d sec, abort current query execution, start:%" PRId64
+ qDebug("QInfo:%" PRIu64 " retrieve not arrive beyond %d ms, abort current query execution, start:%" PRId64
", current:%d", pQInfo->qId, 1, pQInfo->startExecTs, taosGetTimestampSec());
return true;
}
@@ -8413,6 +8413,7 @@ SQInfo* createQInfoImpl(SQueryTableMsg* pQueryMsg, SGroupbyExpr* pGroupbyExpr, S
}
pQInfo->qId = qId;
+ pQInfo->startExecTs = 0;
pQInfo->runtimeEnv.pUdfInfo = pUdfInfo;
diff --git a/src/query/src/queryMain.c b/src/query/src/queryMain.c
index d56c12ab8735d0683db146f7000429d4d554dda5..1460fbdc0fd0324da28bf1161c34c564584258cd 100644
--- a/src/query/src/queryMain.c
+++ b/src/query/src/queryMain.c
@@ -35,7 +35,7 @@ typedef struct SQueryMgmt {
bool closed;
} SQueryMgmt;
-static void queryMgmtKillQueryFn(void* handle) {
+static void queryMgmtKillQueryFn(void* handle, void* param1) {
void** fp = (void**)handle;
qKillQuery(*fp);
}
@@ -215,6 +215,51 @@ int32_t qCreateQueryInfo(void* tsdb, int32_t vgId, SQueryTableMsg* pQueryMsg, qi
return code;
}
+#ifdef TEST_IMPL
+// wait moment
+int waitMoment(SQInfo* pQInfo){
+ if(pQInfo->sql) {
+ int ms = 0;
+ char* pcnt = strstr(pQInfo->sql, " count(*)");
+ if(pcnt) return 0;
+
+ char* pos = strstr(pQInfo->sql, " t_");
+ if(pos){
+ pos += 3;
+ ms = atoi(pos);
+ while(*pos >= '0' && *pos <= '9'){
+ pos ++;
+ }
+ char unit_char = *pos;
+ if(unit_char == 'h'){
+ ms *= 3600*1000;
+ } else if(unit_char == 'm'){
+ ms *= 60*1000;
+ } else if(unit_char == 's'){
+ ms *= 1000;
+ }
+ }
+ if(ms == 0) return 0;
+ printf("test wait sleep %dms. sql=%s ...\n", ms, pQInfo->sql);
+
+ if(ms < 1000) {
+ taosMsleep(ms);
+ } else {
+ int used_ms = 0;
+ while(used_ms < ms) {
+ taosMsleep(1000);
+ used_ms += 1000;
+ if(isQueryKilled(pQInfo)){
+ printf("test check query is canceled, sleep break.%s\n", pQInfo->sql);
+ break;
+ }
+ }
+ }
+ }
+ return 1;
+}
+#endif
+
bool qTableQuery(qinfo_t qinfo, uint64_t *qId) {
SQInfo *pQInfo = (SQInfo *)qinfo;
assert(pQInfo && pQInfo->signature == pQInfo);
@@ -228,7 +273,8 @@ bool qTableQuery(qinfo_t qinfo, uint64_t *qId) {
}
*qId = pQInfo->qId;
- pQInfo->startExecTs = taosGetTimestampSec();
+ if(pQInfo->startExecTs == 0)
+ pQInfo->startExecTs = taosGetTimestampMs();
if (isQueryKilled(pQInfo)) {
qDebug("QInfo:0x%"PRIx64" it is already killed, abort", pQInfo->qId);
@@ -259,7 +305,9 @@ bool qTableQuery(qinfo_t qinfo, uint64_t *qId) {
int64_t st = taosGetTimestampUs();
pRuntimeEnv->outputBuf = pRuntimeEnv->proot->exec(pRuntimeEnv->proot, &newgroup);
pQInfo->summary.elapsedTime += (taosGetTimestampUs() - st);
-
+#ifdef TEST_IMPL
+ waitMoment(pQInfo);
+#endif
publishOperatorProfEvent(pRuntimeEnv->proot, QUERY_PROF_AFTER_OPERATOR_EXEC);
pRuntimeEnv->resultInfo.total += GET_NUM_OF_RESULTS(pRuntimeEnv);
@@ -479,7 +527,7 @@ void qQueryMgmtNotifyClosed(void* pQMgmt) {
pQueryMgmt->closed = true;
pthread_mutex_unlock(&pQueryMgmt->lock);
- taosCacheRefresh(pQueryMgmt->qinfoPool, queryMgmtKillQueryFn);
+ taosCacheRefresh(pQueryMgmt->qinfoPool, queryMgmtKillQueryFn, NULL);
}
void qQueryMgmtReOpen(void *pQMgmt) {
@@ -574,3 +622,148 @@ void** qReleaseQInfo(void* pMgmt, void* pQInfo, bool freeHandle) {
taosCacheRelease(pQueryMgmt->qinfoPool, pQInfo, freeHandle);
return 0;
}
+
+//kill by qid
+int32_t qKillQueryByQId(void* pMgmt, int64_t qId, int32_t waitMs, int32_t waitCount) {
+ int32_t error = TSDB_CODE_SUCCESS;
+ void** handle = qAcquireQInfo(pMgmt, qId);
+ if(handle == NULL) return terrno;
+
+ SQInfo* pQInfo = (SQInfo*)(*handle);
+ if (pQInfo == NULL || !isValidQInfo(pQInfo)) {
+ return TSDB_CODE_QRY_INVALID_QHANDLE;
+ }
+ qWarn("QId:0x%"PRIx64" be killed(no memory commit).", pQInfo->qId);
+ setQueryKilled(pQInfo);
+
+ // wait query stop
+ int32_t loop = 0;
+ while (pQInfo->owner != 0) {
+ taosMsleep(waitMs);
+ if(loop++ > waitCount){
+ error = TSDB_CODE_FAILED;
+ break;
+ }
+ }
+
+ qReleaseQInfo(pMgmt, (void **)&handle, true);
+ return error;
+}
+
+// local struct
+typedef struct {
+ int64_t qId;
+ int64_t startExecTs;
+} SLongQuery;
+
+// callbark for sort compare
+static int compareLongQuery(const void* p1, const void* p2) {
+ // sort desc
+ SLongQuery* plq1 = *(SLongQuery**)p1;
+ SLongQuery* plq2 = *(SLongQuery**)p2;
+ if(plq1->startExecTs == plq2->startExecTs) {
+ return 0;
+ } else if(plq1->startExecTs > plq2->startExecTs) {
+ return 1;
+ } else {
+ return -1;
+ }
+}
+
+// callback for taosCacheRefresh
+static void cbFoundItem(void* handle, void* param1) {
+ SQInfo * qInfo = *(SQInfo**) handle;
+ if(qInfo == NULL) return ;
+ SArray* qids = (SArray*) param1;
+ if(qids == NULL) return ;
+
+ bool usedMem = true;
+ bool usedIMem = true;
+ SMemTable* mem = qInfo->query.memRef.snapshot.omem;
+ SMemTable* imem = qInfo->query.memRef.snapshot.imem;
+ if(mem == NULL || T_REF_VAL_GET(mem) == 0)
+ usedMem = false;
+ if(imem == NULL || T_REF_VAL_GET(mem) == 0)
+ usedIMem = false ;
+
+ if(!usedMem && !usedIMem)
+ return ;
+
+ // push to qids
+ SLongQuery* plq = (SLongQuery*)malloc(sizeof(SLongQuery));
+ plq->qId = qInfo->qId;
+ plq->startExecTs = qInfo->startExecTs;
+ taosArrayPush(qids, &plq);
+}
+
+// longquery
+void* qObtainLongQuery(void* param){
+ SQueryMgmt* qMgmt = (SQueryMgmt*)param;
+ if(qMgmt == NULL || qMgmt->qinfoPool == NULL)
+ return NULL;
+ SArray* qids = taosArrayInit(4, sizeof(int64_t*));
+ if(qids == NULL) return NULL;
+ // Get each item
+ taosCacheRefresh(qMgmt->qinfoPool, cbFoundItem, qids);
+
+ size_t cnt = taosArrayGetSize(qids);
+ if(cnt == 0) {
+ taosArrayDestroy(qids);
+ return NULL;
+ }
+ if(cnt > 1)
+ taosArraySort(qids, compareLongQuery);
+
+ return qids;
+}
+
+//solve tsdb no block to commit
+bool qFixedNoBlock(void* pRepo, void* pMgmt, int32_t longQueryMs) {
+ SQueryMgmt *pQueryMgmt = pMgmt;
+ bool fixed = false;
+
+ // qid top list
+ SArray *qids = (SArray*)qObtainLongQuery(pQueryMgmt);
+ if(qids == NULL) return false;
+
+ // kill Query
+ int64_t now = taosGetTimestampMs();
+ size_t cnt = taosArrayGetSize(qids);
+ size_t i;
+ SLongQuery* plq;
+ for(i=0; i < cnt; i++) {
+ plq = (SLongQuery* )taosArrayGetP(qids, i);
+ if(plq->startExecTs > now) continue;
+ if(now - plq->startExecTs >= longQueryMs) {
+ qKillQueryByQId(pMgmt, plq->qId, 500, 10); // wait 50*100 ms
+ if(tsdbNoProblem(pRepo)) {
+ fixed = true;
+ qWarn("QId:0x%"PRIx64" fixed problem after kill this query.", plq->qId);
+ break;
+ }
+ }
+ }
+
+ // free qids
+ for(i=0; i < cnt; i++) {
+ free(taosArrayGetP(qids, i));
+ }
+ taosArrayDestroy(qids);
+ return fixed;
+}
+
+//solve tsdb no block to commit
+bool qSolveCommitNoBlock(void* pRepo, void* pMgmt) {
+ qWarn("pRepo=%p start solve problem.", pRepo);
+ if(qFixedNoBlock(pRepo, pMgmt, 10*60*1000)) {
+ return true;
+ }
+ if(qFixedNoBlock(pRepo, pMgmt, 2*60*1000)){
+ return true;
+ }
+ if(qFixedNoBlock(pRepo, pMgmt, 30*1000)){
+ return true;
+ }
+ qWarn("pRepo=%p solve problem failed.", pRepo);
+ return false;
+}
diff --git a/src/rpc/src/rpcMain.c b/src/rpc/src/rpcMain.c
index e958a8e5ec5b6542d609028ee052d21a9a84d397..9ea5fd539244820f111a3fbb3c60aee088e727c5 100644
--- a/src/rpc/src/rpcMain.c
+++ b/src/rpc/src/rpcMain.c
@@ -407,7 +407,7 @@ void rpcSendRequest(void *shandle, const SRpcEpSet *pEpSet, SRpcMsg *pMsg, int64
if (type == TSDB_MSG_TYPE_QUERY || type == TSDB_MSG_TYPE_CM_RETRIEVE
|| type == TSDB_MSG_TYPE_FETCH || type == TSDB_MSG_TYPE_CM_STABLE_VGROUP
|| type == TSDB_MSG_TYPE_CM_TABLES_META || type == TSDB_MSG_TYPE_CM_TABLE_META
- || type == TSDB_MSG_TYPE_CM_SHOW || type == TSDB_MSG_TYPE_DM_STATUS)
+ || type == TSDB_MSG_TYPE_CM_SHOW || type == TSDB_MSG_TYPE_DM_STATUS || type == TSDB_MSG_TYPE_CM_ALTER_TABLE)
pContext->connType = RPC_CONN_TCPC;
pContext->rid = taosAddRef(tsRpcRefId, pContext);
diff --git a/src/tsdb/inc/tsdbBuffer.h b/src/tsdb/inc/tsdbBuffer.h
index ec6b057aef142fb938993b3a27717c5e64937258..4b650d3993a54f6a98caf00a3605feb37e972ebd 100644
--- a/src/tsdb/inc/tsdbBuffer.h
+++ b/src/tsdb/inc/tsdbBuffer.h
@@ -29,6 +29,7 @@ typedef struct {
int tBufBlocks;
int nBufBlocks;
int nRecycleBlocks;
+ int nElasticBlocks;
int64_t index;
SList* bufBlockList;
} STsdbBufPool;
@@ -41,6 +42,10 @@ int tsdbOpenBufPool(STsdbRepo* pRepo);
void tsdbCloseBufPool(STsdbRepo* pRepo);
SListNode* tsdbAllocBufBlockFromPool(STsdbRepo* pRepo);
int tsdbExpandPool(STsdbRepo* pRepo, int32_t oldTotalBlocks);
-void tsdbRecycleBufferBlock(STsdbBufPool* pPool, SListNode *pNode);
+void tsdbRecycleBufferBlock(STsdbBufPool* pPool, SListNode *pNode, bool bELastic);
+
+// health cite
+STsdbBufBlock *tsdbNewBufBlock(int bufBlockSize);
+void tsdbFreeBufBlock(STsdbBufBlock *pBufBlock);
#endif /* _TD_TSDB_BUFFER_H_ */
diff --git a/src/tsdb/inc/tsdbHealth.h b/src/tsdb/inc/tsdbHealth.h
new file mode 100644
index 0000000000000000000000000000000000000000..324f4312e05fc0ca0200c319728bf692bf476bf6
--- /dev/null
+++ b/src/tsdb/inc/tsdbHealth.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#ifndef _TD_TSDB_HEALTH_H_
+#define _TD_TSDB_HEALTH_H_
+
+bool tsdbUrgeQueryFree(STsdbRepo* pRepo);
+int32_t tsdbInsertNewBlock(STsdbRepo* pRepo);
+
+bool tsdbIdleMemEnough();
+bool tsdbAllowNewBlock(STsdbRepo* pRepo);
+
+#endif /* _TD_TSDB_BUFFER_H_ */
diff --git a/src/tsdb/inc/tsdbint.h b/src/tsdb/inc/tsdbint.h
index 532907ae01be576e40feea2969761846f07170b3..80e92975799f47d68ff72ef80a52efb6fe901b5e 100644
--- a/src/tsdb/inc/tsdbint.h
+++ b/src/tsdb/inc/tsdbint.h
@@ -97,6 +97,7 @@ struct STsdbRepo {
SMergeBuf mergeBuf; //used when update=2
int8_t compactState; // compact state: inCompact/noCompact/waitingCompact?
+ pthread_t* pthread;
};
#define REPO_ID(r) (r)->config.tsdbId
diff --git a/src/tsdb/src/tsdbBuffer.c b/src/tsdb/src/tsdbBuffer.c
index e675bf6f9de04021112d43a1db70cf56cf430f08..70589031f6516a129a5a683b0e76edb23b814e15 100644
--- a/src/tsdb/src/tsdbBuffer.c
+++ b/src/tsdb/src/tsdbBuffer.c
@@ -14,12 +14,10 @@
*/
#include "tsdbint.h"
+#include "tsdbHealth.h"
#define POOL_IS_EMPTY(b) (listNEles((b)->bufBlockList) == 0)
-static STsdbBufBlock *tsdbNewBufBlock(int bufBlockSize);
-static void tsdbFreeBufBlock(STsdbBufBlock *pBufBlock);
-
// ---------------- INTERNAL FUNCTIONS ----------------
STsdbBufPool *tsdbNewBufPool() {
STsdbBufPool *pBufPool = (STsdbBufPool *)calloc(1, sizeof(*pBufPool));
@@ -65,10 +63,10 @@ int tsdbOpenBufPool(STsdbRepo *pRepo) {
STsdbBufPool *pPool = pRepo->pPool;
ASSERT(pPool != NULL);
-
pPool->bufBlockSize = pCfg->cacheBlockSize * 1024 * 1024; // MB
pPool->tBufBlocks = pCfg->totalBlocks;
pPool->nBufBlocks = 0;
+ pPool->nElasticBlocks = 0;
pPool->index = 0;
pPool->nRecycleBlocks = 0;
@@ -120,6 +118,18 @@ SListNode *tsdbAllocBufBlockFromPool(STsdbRepo *pRepo) {
STsdbBufPool *pBufPool = pRepo->pPool;
while (POOL_IS_EMPTY(pBufPool)) {
+ if(tsDeadLockKillQuery) {
+ // supply new Block
+ if(tsdbInsertNewBlock(pRepo) > 0) {
+ tsdbWarn("vgId:%d add new elastic block . elasticBlocks=%d cur free Blocks=%d", REPO_ID(pRepo), pBufPool->nElasticBlocks, pBufPool->bufBlockList->numOfEles);
+ break;
+ } else {
+ // no newBlock, kill query free
+ if(!tsdbUrgeQueryFree(pRepo))
+ tsdbWarn("vgId:%d Urge query free thread start failed.", REPO_ID(pRepo));
+ }
+ }
+
pRepo->repoLocked = false;
pthread_cond_wait(&(pBufPool->poolNotEmpty), &(pRepo->mutex));
pRepo->repoLocked = true;
@@ -139,11 +149,11 @@ SListNode *tsdbAllocBufBlockFromPool(STsdbRepo *pRepo) {
}
// ---------------- LOCAL FUNCTIONS ----------------
-static STsdbBufBlock *tsdbNewBufBlock(int bufBlockSize) {
+STsdbBufBlock *tsdbNewBufBlock(int bufBlockSize) {
STsdbBufBlock *pBufBlock = (STsdbBufBlock *)malloc(sizeof(*pBufBlock) + bufBlockSize);
if (pBufBlock == NULL) {
terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
- goto _err;
+ return NULL;
}
pBufBlock->blockId = 0;
@@ -151,13 +161,9 @@ static STsdbBufBlock *tsdbNewBufBlock(int bufBlockSize) {
pBufBlock->remain = bufBlockSize;
return pBufBlock;
-
-_err:
- tsdbFreeBufBlock(pBufBlock);
- return NULL;
}
-static void tsdbFreeBufBlock(STsdbBufBlock *pBufBlock) { tfree(pBufBlock); }
+ void tsdbFreeBufBlock(STsdbBufBlock *pBufBlock) { tfree(pBufBlock); }
int tsdbExpandPool(STsdbRepo* pRepo, int32_t oldTotalBlocks) {
if (oldTotalBlocks == pRepo->config.totalBlocks) {
@@ -193,10 +199,16 @@ err:
return err;
}
-void tsdbRecycleBufferBlock(STsdbBufPool* pPool, SListNode *pNode) {
+void tsdbRecycleBufferBlock(STsdbBufPool* pPool, SListNode *pNode, bool bELastic) {
STsdbBufBlock *pBufBlock = NULL;
tdListNodeGetData(pPool->bufBlockList, pNode, (void *)(&pBufBlock));
tsdbFreeBufBlock(pBufBlock);
free(pNode);
- pPool->nBufBlocks--;
-}
+ if(bELastic)
+ {
+ pPool->nElasticBlocks--;
+ tsdbWarn("pPool=%p elastic block reduce one . nElasticBlocks=%d cur free Blocks=%d", pPool, pPool->nElasticBlocks, pPool->bufBlockList->numOfEles);
+ }
+ else
+ pPool->nBufBlocks--;
+}
\ No newline at end of file
diff --git a/src/tsdb/src/tsdbHealth.c b/src/tsdb/src/tsdbHealth.c
new file mode 100644
index 0000000000000000000000000000000000000000..8198c480334912b1ce373ceca7b82409f5a644f2
--- /dev/null
+++ b/src/tsdb/src/tsdbHealth.c
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#include "os.h"
+#include "taosmsg.h"
+#include "tarray.h"
+#include "query.h"
+#include "tglobal.h"
+#include "tlist.h"
+#include "tsdbint.h"
+#include "tsdbBuffer.h"
+#include "tsdbLog.h"
+#include "tsdbHealth.h"
+#include "ttimer.h"
+#include "tthread.h"
+
+
+// return malloc new block count
+int32_t tsdbInsertNewBlock(STsdbRepo * pRepo) {
+ STsdbBufPool *pPool = pRepo->pPool;
+ int32_t cnt = 0;
+
+ if(tsdbAllowNewBlock(pRepo)) {
+ STsdbBufBlock *pBufBlock = tsdbNewBufBlock(pPool->bufBlockSize);
+ if (pBufBlock) {
+ if (tdListAppend(pPool->bufBlockList, (void *)(&pBufBlock)) < 0) {
+ // append error
+ tsdbFreeBufBlock(pBufBlock);
+ } else {
+ pPool->nElasticBlocks ++;
+ cnt ++ ;
+ }
+ }
+ }
+ return cnt;
+}
+
+// switch anther thread to run
+void* cbKillQueryFree(void* param) {
+ STsdbRepo* pRepo = (STsdbRepo*)param;
+ // vnode
+ if(pRepo->appH.notifyStatus) {
+ pRepo->appH.notifyStatus(pRepo->appH.appH, TSDB_STATUS_COMMIT_NOBLOCK, TSDB_CODE_SUCCESS);
+ }
+
+ // free
+ if(pRepo->pthread){
+ void* p = pRepo->pthread;
+ pRepo->pthread = NULL;
+ free(p);
+ }
+
+ return NULL;
+}
+
+// return true do free , false do nothing
+bool tsdbUrgeQueryFree(STsdbRepo * pRepo) {
+ // check previous running
+ if(pRepo->pthread && taosThreadRunning(pRepo->pthread)) {
+ tsdbWarn("vgId:%d pre urge thread is runing. nBlocks=%d nElasticBlocks=%d", REPO_ID(pRepo), pRepo->pPool->nBufBlocks, pRepo->pPool->nElasticBlocks);
+ return false;
+ }
+ // create new
+ pRepo->pthread = taosCreateThread(cbKillQueryFree, pRepo);
+ if(pRepo->pthread == NULL) {
+ tsdbError("vgId:%d create urge thread error.", REPO_ID(pRepo));
+ return false;
+ }
+ return true;
+}
+
+bool tsdbAllowNewBlock(STsdbRepo* pRepo) {
+ int32_t nMaxElastic = pRepo->config.totalBlocks/3;
+ STsdbBufPool* pPool = pRepo->pPool;
+ if(pPool->nElasticBlocks >= nMaxElastic) {
+ tsdbWarn("vgId:%d tsdbAllowNewBlock return fasle. nElasticBlock(%d) >= MaxElasticBlocks(%d)", REPO_ID(pRepo), pPool->nElasticBlocks, nMaxElastic);
+ return false;
+ }
+ return true;
+}
+
+bool tsdbNoProblem(STsdbRepo* pRepo) {
+ if(listNEles(pRepo->pPool->bufBlockList) == 0)
+ return false;
+ return true;
+}
\ No newline at end of file
diff --git a/src/tsdb/src/tsdbMain.c b/src/tsdb/src/tsdbMain.c
index 84f21948687436a28c75116da5e4410673d610ae..e0ca98516ffc88f4fc59fcaf78fcaa8c7f16587d 100644
--- a/src/tsdb/src/tsdbMain.c
+++ b/src/tsdb/src/tsdbMain.c
@@ -16,6 +16,8 @@
// no test file errors here
#include "taosdef.h"
#include "tsdbint.h"
+#include "ttimer.h"
+#include "tthread.h"
#define IS_VALID_PRECISION(precision) \
(((precision) >= TSDB_TIME_PRECISION_MILLI) && ((precision) <= TSDB_TIME_PRECISION_NANO))
@@ -126,6 +128,10 @@ int tsdbCloseRepo(STsdbRepo *repo, int toCommit) {
terrno = TSDB_CODE_SUCCESS;
tsdbStopStream(pRepo);
+ if(pRepo->pthread){
+ taosDestoryThread(pRepo->pthread);
+ pRepo->pthread = NULL;
+ }
if (toCommit) {
tsdbSyncCommit(repo);
@@ -547,6 +553,7 @@ static STsdbRepo *tsdbNewRepo(STsdbCfg *pCfg, STsdbAppH *pAppH) {
pRepo->appH = *pAppH;
}
pRepo->repoLocked = false;
+ pRepo->pthread = NULL;
int code = pthread_mutex_init(&(pRepo->mutex), NULL);
if (code != 0) {
diff --git a/src/tsdb/src/tsdbMemTable.c b/src/tsdb/src/tsdbMemTable.c
index e766d97a97a5905db87691426d282a219eef9d68..3890dca5b96c26009dcf3ca72205ca4b1725aa29 100644
--- a/src/tsdb/src/tsdbMemTable.c
+++ b/src/tsdb/src/tsdbMemTable.c
@@ -99,17 +99,22 @@ int tsdbUnRefMemTable(STsdbRepo *pRepo, SMemTable *pMemTable) {
STsdbBufPool *pBufPool = pRepo->pPool;
SListNode *pNode = NULL;
- bool recycleBlocks = pBufPool->nRecycleBlocks > 0;
+ bool addNew = false;
if (tsdbLockRepo(pRepo) < 0) return -1;
while ((pNode = tdListPopHead(pMemTable->bufBlockList)) != NULL) {
if (pBufPool->nRecycleBlocks > 0) {
- tsdbRecycleBufferBlock(pBufPool, pNode);
+ tsdbRecycleBufferBlock(pBufPool, pNode, false);
pBufPool->nRecycleBlocks -= 1;
} else {
- tdListAppendNode(pBufPool->bufBlockList, pNode);
+ if(pBufPool->nElasticBlocks > 0 && listNEles(pBufPool->bufBlockList) > 2) {
+ tsdbRecycleBufferBlock(pBufPool, pNode, true);
+ } else {
+ tdListAppendNode(pBufPool->bufBlockList, pNode);
+ addNew = true;
+ }
}
}
- if (!recycleBlocks) {
+ if (addNew) {
int code = pthread_cond_signal(&pBufPool->poolNotEmpty);
if (code != 0) {
if (tsdbUnlockRepo(pRepo) < 0) return -1;
diff --git a/src/util/inc/tcache.h b/src/util/inc/tcache.h
index e41b544d00e55f7eece904c5957ef9c06063e6c3..40069d7d273caa14ce3b80467b25d68ea476fb75 100644
--- a/src/util/inc/tcache.h
+++ b/src/util/inc/tcache.h
@@ -33,6 +33,7 @@ extern "C" {
#endif
typedef void (*__cache_free_fn_t)(void*);
+typedef void (*__cache_trav_fn_t)(void*, void*);
typedef struct SCacheStatis {
int64_t missCount;
@@ -176,7 +177,7 @@ void taosCacheCleanup(SCacheObj *pCacheObj);
* @param fp
* @return
*/
-void taosCacheRefresh(SCacheObj *pCacheObj, __cache_free_fn_t fp);
+void taosCacheRefresh(SCacheObj *pCacheObj, __cache_trav_fn_t fp, void* param1);
/**
* stop background refresh worker thread
diff --git a/src/util/inc/tconfig.h b/src/util/inc/tconfig.h
index d03ce6e0f1f34478951a84b2ab18020f5cbec92b..462b23697f91e0c32464764bddeda68c8c6398ee 100644
--- a/src/util/inc/tconfig.h
+++ b/src/util/inc/tconfig.h
@@ -20,7 +20,7 @@
extern "C" {
#endif
-#define TSDB_CFG_MAX_NUM 116 // 110 + 6 with lossy option
+#define TSDB_CFG_MAX_NUM 122
#define TSDB_CFG_PRINT_LEN 23
#define TSDB_CFG_OPTION_LEN 24
#define TSDB_CFG_VALUE_LEN 41
diff --git a/src/util/inc/tthread.h b/src/util/inc/tthread.h
new file mode 100644
index 0000000000000000000000000000000000000000..7443ad706dcbef529d857fe823cddd0cc1efbdd3
--- /dev/null
+++ b/src/util/inc/tthread.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#ifndef TDENGINE_TTHREAD_H
+#define TDENGINE_TTHREAD_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "os.h"
+#include "taosdef.h"
+
+// create new thread
+pthread_t* taosCreateThread( void *(*__start_routine) (void *), void* param);
+// destory thread
+bool taosDestoryThread(pthread_t* pthread);
+// thread running return true
+bool taosThreadRunning(pthread_t* pthread);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // TDENGINE_TTHREAD_H
diff --git a/src/util/src/tcache.c b/src/util/src/tcache.c
index 776a0ad9c83c0f133a23f4f2832acd473ed6ccec..589d3d4fa57c42b472319673a72d2e7ab599689f 100644
--- a/src/util/src/tcache.c
+++ b/src/util/src/tcache.c
@@ -505,7 +505,8 @@ void taosCacheRelease(SCacheObj *pCacheObj, void **data, bool _remove) {
typedef struct SHashTravSupp {
SCacheObj* pCacheObj;
int64_t time;
- __cache_free_fn_t fp;
+ __cache_trav_fn_t fp;
+ void* param1;
} SHashTravSupp;
static bool travHashTableEmptyFn(void* param, void* data) {
@@ -645,7 +646,7 @@ void doCleanupDataCache(SCacheObj *pCacheObj) {
// todo memory leak if there are object with refcount greater than 0 in hash table?
taosHashCleanup(pCacheObj->pHashTable);
- taosTrashcanEmpty(pCacheObj, false);
+ taosTrashcanEmpty(pCacheObj, true);
__cache_lock_destroy(pCacheObj);
@@ -667,17 +668,17 @@ bool travHashTableFn(void* param, void* data) {
}
if (ps->fp) {
- (ps->fp)(pNode->data);
+ (ps->fp)(pNode->data, ps->param1);
}
// do not remove element in hash table
return true;
}
-static void doCacheRefresh(SCacheObj* pCacheObj, int64_t time, __cache_free_fn_t fp) {
+static void doCacheRefresh(SCacheObj* pCacheObj, int64_t time, __cache_trav_fn_t fp, void* param1) {
assert(pCacheObj != NULL);
- SHashTravSupp sup = {.pCacheObj = pCacheObj, .fp = fp, .time = time};
+ SHashTravSupp sup = {.pCacheObj = pCacheObj, .fp = fp, .time = time, .param1 = param1};
taosHashCondTraverse(pCacheObj->pHashTable, travHashTableFn, &sup);
}
@@ -748,7 +749,7 @@ void* taosCacheTimedRefresh(void *handle) {
// refresh data in hash table
if (elemInHash > 0) {
int64_t now = taosGetTimestampMs();
- doCacheRefresh(pCacheObj, now, NULL);
+ doCacheRefresh(pCacheObj, now, NULL, NULL);
}
taosTrashcanEmpty(pCacheObj, false);
@@ -766,13 +767,13 @@ void* taosCacheTimedRefresh(void *handle) {
return NULL;
}
-void taosCacheRefresh(SCacheObj *pCacheObj, __cache_free_fn_t fp) {
+void taosCacheRefresh(SCacheObj *pCacheObj, __cache_trav_fn_t fp, void* param1) {
if (pCacheObj == NULL) {
return;
}
int64_t now = taosGetTimestampMs();
- doCacheRefresh(pCacheObj, now, fp);
+ doCacheRefresh(pCacheObj, now, fp, param1);
}
void taosStopCacheRefreshWorker(void) {
diff --git a/src/util/src/terror.c b/src/util/src/terror.c
index 311abe70df65f6090aa06b4857adb434f4d2f9a0..8fb39cd1702fe670e44f2e0db1639a0f48ab5ab0 100644
--- a/src/util/src/terror.c
+++ b/src/util/src/terror.c
@@ -112,9 +112,10 @@ TAOS_DEFINE_ERROR(TSDB_CODE_TSC_EXCEED_SQL_LIMIT, "SQL statement too lon
TAOS_DEFINE_ERROR(TSDB_CODE_TSC_FILE_EMPTY, "File is empty")
TAOS_DEFINE_ERROR(TSDB_CODE_TSC_LINE_SYNTAX_ERROR, "Syntax error in Line")
TAOS_DEFINE_ERROR(TSDB_CODE_TSC_NO_META_CACHED, "No table meta cached")
-TAOS_DEFINE_ERROR(TSDB_CODE_TSC_DUP_COL_NAMES, "duplicated column names")
-TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_TAG_LENGTH, "Invalid tag length")
-TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_COLUMN_LENGTH, "Invalid column length")
+TAOS_DEFINE_ERROR(TSDB_CODE_TSC_DUP_COL_NAMES, "duplicated column names")
+TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_TAG_LENGTH, "Invalid tag length")
+TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_COLUMN_LENGTH, "Invalid column length")
+TAOS_DEFINE_ERROR(TSDB_CODE_TSC_DUP_TAG_NAMES, "duplicated tag names")
// mnode
TAOS_DEFINE_ERROR(TSDB_CODE_MND_MSG_NOT_PROCESSED, "Message not processed")
diff --git a/src/util/src/tthread.c b/src/util/src/tthread.c
new file mode 100644
index 0000000000000000000000000000000000000000..043b2de2f241297d209041294428dde2c55e974e
--- /dev/null
+++ b/src/util/src/tthread.c
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#include "os.h"
+#include "tthread.h"
+#include "tglobal.h"
+#include "taosdef.h"
+#include "tutil.h"
+#include "tulog.h"
+#include "taoserror.h"
+
+// create new thread
+pthread_t* taosCreateThread( void *(*__start_routine) (void *), void* param) {
+ pthread_t* pthread = (pthread_t*)malloc(sizeof(pthread_t));
+ pthread_attr_t thattr;
+ pthread_attr_init(&thattr);
+ pthread_attr_setdetachstate(&thattr, PTHREAD_CREATE_JOINABLE);
+ int32_t ret = pthread_create(pthread, &thattr, __start_routine, param);
+ pthread_attr_destroy(&thattr);
+
+ if (ret != 0) {
+ free(pthread);
+ return NULL;
+ }
+ return pthread;
+}
+
+// destory thread
+bool taosDestoryThread(pthread_t* pthread) {
+ if(pthread == NULL) return false;
+ if(taosThreadRunning(pthread)) {
+ pthread_cancel(*pthread);
+ pthread_join(*pthread, NULL);
+ }
+
+ free(pthread);
+ return true;
+}
+
+// thread running return true
+bool taosThreadRunning(pthread_t* pthread) {
+ if(pthread == NULL) return false;
+ int ret = pthread_kill(*pthread, 0);
+ if(ret == ESRCH)
+ return false;
+ if(ret == EINVAL)
+ return false;
+ // alive
+ return true;
+}
diff --git a/src/vnode/src/vnodeMain.c b/src/vnode/src/vnodeMain.c
index f826c1aecd336a0eedeb3f02df0a7acc61895bb2..c823880ae2028c4bcfe26dbfc5cd60af62443722 100644
--- a/src/vnode/src/vnodeMain.c
+++ b/src/vnode/src/vnodeMain.c
@@ -560,5 +560,10 @@ static int32_t vnodeProcessTsdbStatus(void *arg, int32_t status, int32_t eno) {
return vnodeSaveVersion(pVnode);
}
+ // timer thread callback
+ if(status == TSDB_STATUS_COMMIT_NOBLOCK) {
+ qSolveCommitNoBlock(pVnode->tsdb, pVnode->qMgmt);
+ }
+
return 0;
}
diff --git a/tests/connectorTest/nodejsTest/test/nanosecondTest.js b/tests/connectorTest/nodejsTest/test/nanosecondTest.js
deleted file mode 100644
index 36fb398ea4acc51eeae1dd0549aca503aabdba0e..0000000000000000000000000000000000000000
--- a/tests/connectorTest/nodejsTest/test/nanosecondTest.js
+++ /dev/null
@@ -1,351 +0,0 @@
-const taos = require('../tdengine');
-var conn = taos.connect({config:"/etc/taos"});
-var c1 = conn.cursor();
-
-
-function checkData(sql,row,col,data){
-
- c1.execute(sql)
- var d = c1.fetchall();
- let checkdata = d[row][col];
- if (checkdata == data) {
-
- // console.log('check pass')
- }
- else{
- console.log('check failed')
- console.log(checkdata)
- console.log(data)
-
-
- }
-}
-
-
-// nano basic case
-
-c1.execute('reset query cache')
-c1.execute('drop database if exists db')
-c1.execute('create database db precision "ns";')
-c1.execute('use db');
-c1.execute('create table tb (ts timestamp, speed int)')
-c1.execute('insert into tb values(\'2021-06-10 00:00:00.100000001\', 1);')
-c1.execute('insert into tb values(1623254400150000000, 2);')
-c1.execute('import into tb values(1623254400300000000, 3);')
-c1.execute('import into tb values(1623254400299999999, 4);')
-c1.execute('insert into tb values(1623254400300000001, 5);')
-c1.execute('insert into tb values(1623254400999999999, 7);')
-c1.execute('insert into tb values(1623254400123456789, 8);')
-sql = 'select * from tb;'
-
-console.log('*******************************************')
-console.log('this is area about checkdata result')
-//check data about insert data
-checkData(sql,0,0,'2021-06-10 00:00:00.100000001')
-checkData(sql,1,0,'2021-06-10 00:00:00.123456789')
-checkData(sql,2,0,'2021-06-10 00:00:00.150000000')
-checkData(sql,3,0,'2021-06-10 00:00:00.299999999') //error
-checkData(sql,4,0,'2021-06-10 00:00:00.300000000')
-checkData(sql,5,0,'2021-06-10 00:00:00.300000001')
-checkData(sql,6,0,'2021-06-10 00:00:00.999999999') //error
-
-// // us basic case
-
-// c1.execute('reset query cache')
-// c1.execute('drop database if exists db')
-// c1.execute('create database db precision "us";')
-// c1.execute('use db');
-// c1.execute('create table tb (ts timestamp, speed int)')
-// c1.execute('insert into tb values(\'2021-06-10 00:00:00.100001\', 1);')
-// c1.execute('insert into tb values(1623254400150000, 2);')
-// c1.execute('import into tb values(1623254400300000, 3);')
-// c1.execute('import into tb values(1623254400299999, 4);')
-// c1.execute('insert into tb values(1623254400300001, 5);')
-// c1.execute('insert into tb values(1623254400999999, 7);')
-// c1.execute('insert into tb values(1623254400123789, 8);')
-// sql = 'select * from tb;'
-
-// console.log('*******************************************')
-
-// //check data about insert data
-// checkData(sql,0,0,'2021-06-10 00:00:00.100001')
-// checkData(sql,1,0,'2021-06-10 00:00:00.123789')
-// checkData(sql,2,0,'2021-06-10 00:00:00.150000')
-// checkData(sql,3,0,'2021-06-10 00:00:00.299999')
-// checkData(sql,4,0,'2021-06-10 00:00:00.300000')
-// checkData(sql,5,0,'2021-06-10 00:00:00.300001')
-// checkData(sql,6,0,'2021-06-10 00:00:00.999999')
-
-// console.log('*******************************************')
-
-// // ms basic case
-
-// c1.execute('reset query cache')
-// c1.execute('drop database if exists db')
-// c1.execute('create database db precision "ms";')
-// c1.execute('use db');
-// c1.execute('create table tb (ts timestamp, speed int)')
-// c1.execute('insert into tb values(\'2021-06-10 00:00:00.101\', 1);')
-// c1.execute('insert into tb values(1623254400150, 2);')
-// c1.execute('import into tb values(1623254400300, 3);')
-// c1.execute('import into tb values(1623254400299, 4);')
-// c1.execute('insert into tb values(1623254400301, 5);')
-// c1.execute('insert into tb values(1623254400789, 7);')
-// c1.execute('insert into tb values(1623254400999, 8);')
-// sql = 'select * from tb;'
-
-// console.log('*******************************************')
-// console.log('this is area about checkdata result')
-// //check data about insert data
-// checkData(sql,0,0,'2021-06-10 00:00:00.101')
-// checkData(sql,1,0,'2021-06-10 00:00:00.150')
-// checkData(sql,2,0,'2021-06-10 00:00:00.299')
-// checkData(sql,3,0,'2021-06-10 00:00:00.300')
-// checkData(sql,4,0,'2021-06-10 00:00:00.301')
-// checkData(sql,5,0,'2021-06-10 00:00:00.789')
-// checkData(sql,6,0,'2021-06-10 00:00:00.999')
-
-console.log('*******************************************')
-
-// offfical query result to show
-// console.log('this is area about fetch all data')
-// var query = c1.query(sql)
-// var promise = query.execute();
-// promise.then(function(result) {
-// result.pretty();
-// });
-
-console.log('*******************************************')
-// checkData(sql,3,1,3)
-// checkData(sql,4,1,5)
-// checkData(sql,5,1,7)
-
-
-
-
-
-
-// checkData(3,1,3)
-// checkData(4,1,5)
-// checkData(5,1,7)
-
-// tdSql.query('select count(*) from tb where ts > 1623254400100000000 and ts < 1623254400100000002;')
-// tdSql.checkData(0,0,1)
-// tdSql.query('select count(*) from tb where ts > \'2021-06-10 0:00:00.100000001\' and ts < \'2021-06-10 0:00:00.160000000\';')
-// tdSql.checkData(0,0,1)
-
-// tdSql.query('select count(*) from tb where ts > 1623254400100000000 and ts < 1623254400150000000;')
-// tdSql.checkData(0,0,1)
-// tdSql.query('select count(*) from tb where ts > \'2021-06-10 0:00:00.100000000\' and ts < \'2021-06-10 0:00:00.150000000\';')
-// tdSql.checkData(0,0,1)
-
-// tdSql.query('select count(*) from tb where ts > 1623254400400000000;')
-// tdSql.checkData(0,0,1)
-// tdSql.query('select count(*) from tb where ts < \'2021-06-10 00:00:00.400000000\';')
-// tdSql.checkData(0,0,5)
-
-// tdSql.query('select count(*) from tb where ts > now + 400000000b;')
-// tdSql.checkRows(0)
-
-// tdSql.query('select count(*) from tb where ts >= \'2021-06-10 0:00:00.100000001\';')
-// tdSql.checkData(0,0,6)
-
-// tdSql.query('select count(*) from tb where ts <= 1623254400300000000;')
-// tdSql.checkData(0,0,4)
-
-// tdSql.query('select count(*) from tb where ts = \'2021-06-10 0:00:00.000000000\';')
-// tdSql.checkRows(0)
-
-// tdSql.query('select count(*) from tb where ts = 1623254400150000000;')
-// tdSql.checkData(0,0,1)
-
-// tdSql.query('select count(*) from tb where ts = \'2021-06-10 0:00:00.100000001\';')
-// tdSql.checkData(0,0,1)
-
-// tdSql.query('select count(*) from tb where ts between 1623254400000000000 and 1623254400400000000;')
-// tdSql.checkData(0,0,5)
-
-// tdSql.query('select count(*) from tb where ts between \'2021-06-10 0:00:00.299999999\' and \'2021-06-10 0:00:00.300000001\';')
-// tdSql.checkData(0,0,3)
-
-// tdSql.query('select avg(speed) from tb interval(5000000000b);')
-// tdSql.checkRows(1)
-
-// tdSql.query('select avg(speed) from tb interval(100000000b)')
-// tdSql.checkRows(4)
-
-// tdSql.error('select avg(speed) from tb interval(1b);')
-// tdSql.error('select avg(speed) from tb interval(999b);')
-
-// tdSql.query('select avg(speed) from tb interval(1000b);')
-// tdSql.checkRows(5)
-
-// tdSql.query('select avg(speed) from tb interval(1u);')
-// tdSql.checkRows(5)
-
-// tdSql.query('select avg(speed) from tb interval(100000000b) sliding (100000000b);')
-// tdSql.checkRows(4)
-
-// tdSql.query('select last(*) from tb')
-// tdSql.checkData(0,0, '2021-06-10 0:00:00.999999999')
-// tdSql.checkData(0,0, 1623254400999999999)
-
-// tdSql.query('select first(*) from tb')
-// tdSql.checkData(0,0, 1623254400100000001)
-// tdSql.checkData(0,0, '2021-06-10 0:00:00.100000001')
-
-// c1.execute('insert into tb values(now + 500000000b, 6);')
-// tdSql.query('select * from tb;')
-// tdSql.checkRows(7)
-
-// tdLog.debug('testing nanosecond support in other timestamps')
-// c1.execute('create table tb2 (ts timestamp, speed int, ts2 timestamp);')
-// c1.execute('insert into tb2 values(\'2021-06-10 0:00:00.100000001\', 1, \'2021-06-11 0:00:00.100000001\');')
-// c1.execute('insert into tb2 values(1623254400150000000, 2, 1623340800150000000);')
-// c1.execute('import into tb2 values(1623254400300000000, 3, 1623340800300000000);')
-// c1.execute('import into tb2 values(1623254400299999999, 4, 1623340800299999999);')
-// c1.execute('insert into tb2 values(1623254400300000001, 5, 1623340800300000001);')
-// c1.execute('insert into tb2 values(1623254400999999999, 7, 1623513600999999999);')
-
-// tdSql.query('select * from tb2;')
-// tdSql.checkData(0,0,'2021-06-10 0:00:00.100000001')
-// tdSql.checkData(1,0,'2021-06-10 0:00:00.150000000')
-// tdSql.checkData(2,1,4)
-// tdSql.checkData(3,1,3)
-// tdSql.checkData(4,2,'2021-06-11 00:00:00.300000001')
-// tdSql.checkData(5,2,'2021-06-13 00:00:00.999999999')
-// tdSql.checkRows(6)
-// tdSql.query('select count(*) from tb2 where ts2 > 1623340800000000000 and ts2 < 1623340800150000000;')
-// tdSql.checkData(0,0,1)
-// tdSql.query('select count(*) from tb2 where ts2 > \'2021-06-11 0:00:00.100000000\' and ts2 < \'2021-06-11 0:00:00.100000002\';')
-// tdSql.checkData(0,0,1)
-
-// tdSql.query('select count(*) from tb2 where ts2 > 1623340800500000000;')
-// tdSql.checkData(0,0,1)
-// tdSql.query('select count(*) from tb2 where ts2 < \'2021-06-11 0:00:00.400000000\';')
-// tdSql.checkData(0,0,5)
-
-// tdSql.query('select count(*) from tb2 where ts2 > now + 400000000b;')
-// tdSql.checkRows(0)
-
-// tdSql.query('select count(*) from tb2 where ts2 >= \'2021-06-11 0:00:00.100000001\';')
-// tdSql.checkData(0,0,6)
-
-// tdSql.query('select count(*) from tb2 where ts2 <= 1623340800400000000;')
-// tdSql.checkData(0,0,5)
-
-// tdSql.query('select count(*) from tb2 where ts2 = \'2021-06-11 0:00:00.000000000\';')
-// tdSql.checkRows(0)
-
-// tdSql.query('select count(*) from tb2 where ts2 = \'2021-06-11 0:00:00.300000001\';')
-// tdSql.checkData(0,0,1)
-
-// tdSql.query('select count(*) from tb2 where ts2 = 1623340800300000001;')
-// tdSql.checkData(0,0,1)
-
-// tdSql.query('select count(*) from tb2 where ts2 between 1623340800000000000 and 1623340800450000000;')
-// tdSql.checkData(0,0,5)
-
-// tdSql.query('select count(*) from tb2 where ts2 between \'2021-06-11 0:00:00.299999999\' and \'2021-06-11 0:00:00.300000001\';')
-// tdSql.checkData(0,0,3)
-
-// tdSql.query('select count(*) from tb2 where ts2 <> 1623513600999999999;')
-// tdSql.checkData(0,0,5)
-
-// tdSql.query('select count(*) from tb2 where ts2 <> \'2021-06-11 0:00:00.100000001\';')
-// tdSql.checkData(0,0,5)
-
-// tdSql.query('select count(*) from tb2 where ts2 <> \'2021-06-11 0:00:00.100000000\';')
-// tdSql.checkData(0,0,6)
-
-// tdSql.query('select count(*) from tb2 where ts2 != 1623513600999999999;')
-// tdSql.checkData(0,0,5)
-
-// tdSql.query('select count(*) from tb2 where ts2 != \'2021-06-11 0:00:00.100000001\';')
-// tdSql.checkData(0,0,5)
-
-// tdSql.query('select count(*) from tb2 where ts2 != \'2021-06-11 0:00:00.100000000\';')
-// tdSql.checkData(0,0,6)
-
-// c1.execute('insert into tb2 values(now + 500000000b, 6, now +2d);')
-// tdSql.query('select * from tb2;')
-// tdSql.checkRows(7)
-
-// tdLog.debug('testing ill nanosecond format handling')
-// c1.execute('create table tb3 (ts timestamp, speed int);')
-
-// tdSql.error('insert into tb3 values(16232544001500000, 2);')
-// c1.execute('insert into tb3 values(\'2021-06-10 0:00:00.123456\', 2);')
-// tdSql.query('select * from tb3 where ts = \'2021-06-10 0:00:00.123456000\';')
-// tdSql.checkRows(1)
-
-// c1.execute('insert into tb3 values(\'2021-06-10 0:00:00.123456789000\', 2);')
-// tdSql.query('select * from tb3 where ts = \'2021-06-10 0:00:00.123456789\';')
-// tdSql.checkRows(1)
-
-// # check timezone support
-
-// c1.execute('use db;')
-// c1.execute('create stable st (ts timestamp ,speed float ) tags(time timestamp ,id int);')
-// c1.execute('insert into tb1 using st tags("2021-06-10 0:00:00.123456789" , 1 ) values("2021-06-10 0:00:00.123456789+07:00" , 1.0);' )
-// tdSql.query("select first(*) from tb1;")
-// tdSql.checkData(0,0,1623258000123456789)
-// c1.execute('insert into tb1 using st tags("2021-06-10 0:00:00.123456789" , 1 ) values("2021-06-10T0:00:00.123456789+06:00" , 2.0);' )
-// tdSql.query("select last(*) from tb1;")
-// tdSql.checkData(0,0,1623261600123456789)
-
-// c1.execute('create database usdb precision "us";')
-// c1.execute('use usdb;')
-// c1.execute('create stable st (ts timestamp ,speed float ) tags(time timestamp ,id int);')
-// c1.execute('insert into tb1 using st tags("2021-06-10 0:00:00.123456" , 1 ) values("2021-06-10 0:00:00.123456+07:00" , 1.0);' )
-// res = tdSql.getResult("select first(*) from tb1;")
-// print(res)
-// if res == [(datetime.datetime(2021, 6, 10, 1, 0, 0, 123456), 1.0)]:
-// tdLog.info('check timezone pass about us database')
-
-// c1.execute('create database msdb precision "ms";')
-// c1.execute('use msdb;')
-// c1.execute('create stable st (ts timestamp ,speed float ) tags(time timestamp ,id int);')
-// c1.execute('insert into tb1 using st tags("2021-06-10 0:00:00.123" , 1 ) values("2021-06-10 0:00:00.123+07:00" , 1.0);' )
-// res = tdSql.getResult("select first(*) from tb1;")
-// print(res)
-// if res ==[(datetime.datetime(2021, 6, 10, 1, 0, 0, 123000), 1.0)]:
-// tdLog.info('check timezone pass about ms database')
-
-
-
-
-
-
-
-
-
-
-// c1.execute('create database if not exists ' + dbname + ' precision "ns"');
-// c1.execute('use ' + dbname)
-// c1.execute('create table if not exists tstest (ts timestamp, _int int);');
-// c1.execute('insert into tstest values(1625801548423914405, 0)');
-// // Select
-// console.log('select * from tstest');
-// c1.execute('select * from tstest');
-
-// var d = c1.fetchall();
-// console.log(c1.fields);
-// let ts = d[0][0];
-// console.log(ts);
-
-// if (ts.taosTimestamp() != 1625801548423914405) {
-// throw "nanosecond not match!";
-// }
-// if (ts.getNanoseconds() % 1000000 !== 914405) {
-// throw "nanosecond precision error";
-// }
-// setTimeout(function () {
-// c1.query('drop database nodejs_ns_test;');
-// }, 200);
-
-// setTimeout(function () {
-// conn.close();
-// }, 2000);
-
-
diff --git a/tests/examples/C#/taosdemo/Dockerfile b/tests/examples/C#/taosdemo/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..4eefc6c75248b1e1e1d6daf305386cca5b11e606
--- /dev/null
+++ b/tests/examples/C#/taosdemo/Dockerfile
@@ -0,0 +1,24 @@
+FROM tdengine/tdengine-beta:latest
+
+ENV DEBIAN_FRONTEND=noninteractive
+ARG MIRROR=archive.ubuntu.com
+RUN sed -Ei 's/\w+.ubuntu.com/'${MIRROR}'/' /etc/apt/sources.list && apt update && apt install mono-devel -y
+RUN apt-get install wget -y \
+ && wget https://packages.microsoft.com/config/ubuntu/18.04/packages-microsoft-prod.deb -O packages-microsoft-prod.deb \
+ && dpkg -i packages-microsoft-prod.deb \
+ && rm packages-microsoft-prod.deb \
+ && apt-get update && apt-get install -y dotnet-sdk-5.0
+COPY ./*.cs *.csproj /tmp/
+WORKDIR /tmp/
+RUN dotnet build -c Release && cp bin/Release/net5.0/taosdemo bin/Release/net5.0/taosdemo.* /usr/local/bin/ && rm -rf /tmp/*
+
+FROM tdengine/tdengine-beta:latest
+
+ENV DEBIAN_FRONTEND=noninteractive
+RUN apt-get update && apt-get install wget -y \
+ && wget https://packages.microsoft.com/config/ubuntu/18.04/packages-microsoft-prod.deb -O packages-microsoft-prod.deb \
+ && dpkg -i packages-microsoft-prod.deb \
+ && rm packages-microsoft-prod.deb \
+ && apt-get update && apt-get install -y dotnet-runtime-5.0
+COPY --from=0 /usr/local/bin/taosdemo* /usr/local/bin/
+CMD ["/usr/local/bin/taosdemo"]
diff --git a/tests/examples/C#/taosdemo/README.md b/tests/examples/C#/taosdemo/README.md
index 2d125fb140076c46c9abc4c60db330b28b494802..3cba3529bf513e2bf3d4ab0c169e7f3d03b2e6a8 100644
--- a/tests/examples/C#/taosdemo/README.md
+++ b/tests/examples/C#/taosdemo/README.md
@@ -1,13 +1,41 @@
+# C# Taosdemo
+
+## For Mono
+
install build environment
-===
+
+```sh
yum/apt install mono-complete
+```
-build C# version taosdemo
-===
+build C# version taosdemo.
+
+```sh
mcs -out:taosdemo *.cs
+./taosdemo --help
+```
+
+## For DotNet
+
+install dotnet environment.
+
+```sh
+wget https://packages.microsoft.com/config/ubuntu/18.04/packages-microsoft-prod.deb -O packages-microsoft-prod.deb \
+ && dpkg -i packages-microsoft-prod.deb \
+ && rm packages-microsoft-prod.deb \
+ && apt-get update && apt-get install -y dotnet-sdk-5.0
+```
+
+Build DotNet version taosdemo.
+
+```sh
+dotnet build -c Release
+./bin/Release/net5.0/taosdemo --help
+```
+
+## Usage
-run C# version taosdemo
-===
+```
Usage: mono taosdemo.exe [OPTION...]
--help Show usage.
@@ -34,3 +62,4 @@ Usage: mono taosdemo.exe [OPTION...]
-v Print verbose output
-g Print debug output
-y Skip read key for continous test, default is not skip
+```
diff --git a/tests/examples/C#/taosdemo/taosdemo.csproj b/tests/examples/C#/taosdemo/taosdemo.csproj
new file mode 100644
index 0000000000000000000000000000000000000000..15ec155d45e34aae7276fe596c177619dfddd3e9
--- /dev/null
+++ b/tests/examples/C#/taosdemo/taosdemo.csproj
@@ -0,0 +1,9 @@
+
+
+
+ Exe
+ net5.0
+ false
+
+
+
diff --git a/tests/examples/c/apitest.c b/tests/examples/c/apitest.c
index 01169715f3e8b5b9d6e212b4b317ecca5fa4dbcd..621950a834c515962f35e000279bc91e4c25b5e0 100644
--- a/tests/examples/c/apitest.c
+++ b/tests/examples/c/apitest.c
@@ -1,12 +1,15 @@
// sample code to verify all TDengine API
// to compile: gcc -o apitest apitest.c -ltaos
+#include "taoserror.h"
+
#include
#include
#include
#include
#include
+
static void prepare_data(TAOS* taos) {
TAOS_RES *result;
result = taos_query(taos, "drop database if exists test;");
@@ -1014,6 +1017,186 @@ int32_t verify_schema_less(TAOS* taos) {
return (code);
}
+void verify_telnet_insert(TAOS* taos) {
+ TAOS_RES *result;
+
+ result = taos_query(taos, "drop database if exists test;");
+ taos_free_result(result);
+ usleep(100000);
+ result = taos_query(taos, "create database db precision 'ms';");
+ taos_free_result(result);
+ usleep(100000);
+
+ (void)taos_select_db(taos, "db");
+ int32_t code = 0;
+
+ /* metric */
+ char* lines0[] = {
+ "stb0_0 1626006833639000000ns 4i8 host=\"host0\",interface=\"eth0\"",
+ "stb0_1 1626006833639000000ns 4i8 host=\"host0\",interface=\"eth0\"",
+ "stb0_2 1626006833639000000ns 4i8 host=\"host0\",interface=\"eth0\"",
+ };
+ code = taos_insert_telnet_lines(taos, lines0, 3);
+ if (code) {
+ printf("code: %d, %s.\n", code, tstrerror(code));
+ }
+
+ /* timestamp */
+ char* lines1[] = {
+ "stb1 1626006833s 1i8 host=\"host0\"",
+ "stb1 1626006833639000000ns 2i8 host=\"host0\"",
+ "stb1 1626006833640000us 3i8 host=\"host0\"",
+ "stb1 1626006833641123 4i8 host=\"host0\"",
+ "stb1 1626006833651ms 5i8 host=\"host0\"",
+ "stb1 0 6i8 host=\"host0\"",
+ };
+ code = taos_insert_telnet_lines(taos, lines1, 6);
+ if (code) {
+ printf("code: %d, %s.\n", code, tstrerror(code));
+ }
+
+ /* metric value */
+ //tinyin
+ char* lines2_0[] = {
+ "stb2_0 1626006833651ms -127i8 host=\"host0\"",
+ "stb2_0 1626006833652ms 127i8 host=\"host0\""
+ };
+ code = taos_insert_telnet_lines(taos, lines2_0, 2);
+ if (code) {
+ printf("code: %d, %s.\n", code, tstrerror(code));
+ }
+
+ //smallint
+ char* lines2_1[] = {
+ "stb2_1 1626006833651ms -32767i16 host=\"host0\"",
+ "stb2_1 1626006833652ms 32767i16 host=\"host0\""
+ };
+ code = taos_insert_telnet_lines(taos, lines2_1, 2);
+ if (code) {
+ printf("code: %d, %s.\n", code, tstrerror(code));
+ }
+
+ //int
+ char* lines2_2[] = {
+ "stb2_2 1626006833651ms -2147483647i32 host=\"host0\"",
+ "stb2_2 1626006833652ms 2147483647i32 host=\"host0\""
+ };
+ code = taos_insert_telnet_lines(taos, lines2_2, 2);
+ if (code) {
+ printf("code: %d, %s.\n", code, tstrerror(code));
+ }
+
+ //bigint
+ char* lines2_3[] = {
+ "stb2_3 1626006833651ms -9223372036854775807i64 host=\"host0\"",
+ "stb2_3 1626006833652ms 9223372036854775807i64 host=\"host0\""
+ };
+ code = taos_insert_telnet_lines(taos, lines2_3, 2);
+ if (code) {
+ printf("code: %d, %s.\n", code, tstrerror(code));
+ }
+
+ //float
+ char* lines2_4[] = {
+ "stb2_4 1626006833610ms 3f32 host=\"host0\"",
+ "stb2_4 1626006833620ms -3f32 host=\"host0\"",
+ "stb2_4 1626006833630ms 3.4f32 host=\"host0\"",
+ "stb2_4 1626006833640ms -3.4f32 host=\"host0\"",
+ "stb2_4 1626006833650ms 3.4E10f32 host=\"host0\"",
+ "stb2_4 1626006833660ms -3.4e10f32 host=\"host0\"",
+ "stb2_4 1626006833670ms 3.4E+2f32 host=\"host0\"",
+ "stb2_4 1626006833680ms -3.4e-2f32 host=\"host0\"",
+ "stb2_4 1626006833690ms 3.15 host=\"host0\"",
+ "stb2_4 1626006833700ms 3.4E38f32 host=\"host0\"",
+ "stb2_4 1626006833710ms -3.4E38f32 host=\"host0\""
+ };
+ code = taos_insert_telnet_lines(taos, lines2_4, 11);
+ if (code) {
+ printf("code: %d, %s.\n", code, tstrerror(code));
+ }
+
+ //double
+ char* lines2_5[] = {
+ "stb2_5 1626006833610ms 3f64 host=\"host0\"",
+ "stb2_5 1626006833620ms -3f64 host=\"host0\"",
+ "stb2_5 1626006833630ms 3.4f64 host=\"host0\"",
+ "stb2_5 1626006833640ms -3.4f64 host=\"host0\"",
+ "stb2_5 1626006833650ms 3.4E10f64 host=\"host0\"",
+ "stb2_5 1626006833660ms -3.4e10f64 host=\"host0\"",
+ "stb2_5 1626006833670ms 3.4E+2f64 host=\"host0\"",
+ "stb2_5 1626006833680ms -3.4e-2f64 host=\"host0\"",
+ "stb2_5 1626006833690ms 1.7E308f64 host=\"host0\"",
+ "stb2_5 1626006833700ms -1.7E308f64 host=\"host0\""
+ };
+ code = taos_insert_telnet_lines(taos, lines2_5, 10);
+ if (code) {
+ printf("code: %d, %s.\n", code, tstrerror(code));
+ }
+
+ //bool
+ char* lines2_6[] = {
+ "stb2_6 1626006833610ms t host=\"host0\"",
+ "stb2_6 1626006833620ms T host=\"host0\"",
+ "stb2_6 1626006833630ms true host=\"host0\"",
+ "stb2_6 1626006833640ms True host=\"host0\"",
+ "stb2_6 1626006833650ms TRUE host=\"host0\"",
+ "stb2_6 1626006833660ms f host=\"host0\"",
+ "stb2_6 1626006833670ms F host=\"host0\"",
+ "stb2_6 1626006833680ms false host=\"host0\"",
+ "stb2_6 1626006833690ms False host=\"host0\"",
+ "stb2_6 1626006833700ms FALSE host=\"host0\""
+ };
+ code = taos_insert_telnet_lines(taos, lines2_6, 10);
+ if (code) {
+ printf("code: %d, %s.\n", code, tstrerror(code));
+ }
+
+ //binary
+ char* lines2_7[] = {
+ "stb2_7 1626006833610ms \"binary_val.!@#$%^&*\" host=\"host0\"",
+ "stb2_7 1626006833620ms \"binary_val.:;,./?|+-=\" host=\"host0\"",
+ "stb2_7 1626006833630ms \"binary_val.()[]{}<>\" host=\"host0\""
+ };
+ code = taos_insert_telnet_lines(taos, lines2_7, 3);
+ if (code) {
+ printf("code: %d, %s.\n", code, tstrerror(code));
+ }
+
+ //nchar
+ char* lines2_8[] = {
+ "stb2_8 1626006833610ms L\"nchar_val数值一\" host=\"host0\"",
+ "stb2_8 1626006833620ms L\"nchar_val数值二\" host=\"host0\"",
+ };
+ code = taos_insert_telnet_lines(taos, lines2_8, 2);
+ if (code) {
+ printf("code: %d, %s.\n", code, tstrerror(code));
+ }
+
+ /* tags */
+ //tag value types
+ char* lines3_0[] = {
+ "stb3_0 1626006833610ms 1 t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=3.4E38f32,t6=1.7E308f64,t7=true,t8=\"binary_val_1\",t9=L\"标签值1\"",
+ "stb3_0 1626006833610ms 2 t1=-127i8,t2=-32767i16,t3=-2147483647i32,t4=-9223372036854775807i64,t5=-3.4E38f32,t6=-1.7E308f64,t7=false,t8=\"binary_val_2\",t9=L\"标签值2\""
+ };
+ code = taos_insert_telnet_lines(taos, lines3_0, 2);
+ if (code) {
+ printf("code: %d, %s.\n", code, tstrerror(code));
+ }
+
+ //tag ID as child table name
+ char* lines3_1[] = {
+ "stb3_1 1626006833610ms 1 id=\"child_table1\",host=\"host1\"",
+ "stb3_1 1626006833610ms 2 host=\"host2\",iD=\"child_table2\"",
+ "stb3_1 1626006833610ms 3 ID=\"child_table3\",host=\"host3\""
+ };
+ code = taos_insert_telnet_lines(taos, lines3_1, 3);
+ if (code) {
+ printf("code: %d, %s.\n", code, tstrerror(code));
+ }
+
+ return;
+}
+
int main(int argc, char *argv[]) {
const char* host = "127.0.0.1";
const char* user = "root";
@@ -1034,6 +1217,8 @@ int main(int argc, char *argv[]) {
printf("************ verify schema-less *************\n");
verify_schema_less(taos);
+ printf("************ verify telnet-insert *************\n");
+ verify_telnet_insert(taos);
printf("************ verify query *************\n");
verify_query(taos);
@@ -1051,7 +1236,7 @@ int main(int argc, char *argv[]) {
verify_prepare2(taos);
printf("************ verify prepare3 *************\n");
verify_prepare3(taos);
-
+
printf("************ verify stream *************\n");
verify_stream(taos);
printf("done\n");
diff --git a/tests/gotest/batchtest.bat b/tests/gotest/batchtest.bat
index efd8961bb0be2eb6f20e291114b92b00469b984f..2a96ee31eb6211dbc5f300fbb2f3d62c03df3061 100755
--- a/tests/gotest/batchtest.bat
+++ b/tests/gotest/batchtest.bat
@@ -1,3 +1,4 @@
+
@echo off
echo ==== start Go connector test cases test ====
cd /d %~dp0
@@ -18,3 +19,10 @@ rem case002.bat
:: cd case002
:: case002.bat
+
+
+rem cd nanosupport
+rem nanoCase.bat
+
+:: cd nanosupport
+:: nanoCase.bat
\ No newline at end of file
diff --git a/tests/gotest/batchtest.sh b/tests/gotest/batchtest.sh
index 95d984a7013ef4e7715af8764531434a564a382b..503d77b226885b10e3874a3e0718789bed34b200 100755
--- a/tests/gotest/batchtest.sh
+++ b/tests/gotest/batchtest.sh
@@ -19,6 +19,4 @@ go env -w GOPROXY=https://goproxy.io,direct
bash ./case001/case001.sh $severIp $serverPort
bash ./case002/case002.sh $severIp $serverPort
#bash ./case003/case003.sh $severIp $serverPort
-
-cd nanosupport
-go run main.go
+bash ./nanosupport/nanoCase.sh $severIp $serverPort
diff --git a/tests/gotest/case001/demotest b/tests/gotest/case001/demotest
deleted file mode 100755
index c9422c3497d8ebbf45d1cf7a68a408b9f2a5c785..0000000000000000000000000000000000000000
Binary files a/tests/gotest/case001/demotest and /dev/null differ
diff --git a/tests/gotest/case001/go.mod b/tests/gotest/case001/go.mod
deleted file mode 100644
index 71f1979348ad92cf903fc2036aa0a45c0384b7a1..0000000000000000000000000000000000000000
--- a/tests/gotest/case001/go.mod
+++ /dev/null
@@ -1,5 +0,0 @@
-module demotest
-
-go 1.13
-
-require github.com/taosdata/driver-go v0.0.0-20210811072315-2cda9f1dc9ed
diff --git a/tests/gotest/case001/go.sum b/tests/gotest/case001/go.sum
deleted file mode 100644
index 0b56f082753bda620823217408bf5e6f3a41586b..0000000000000000000000000000000000000000
--- a/tests/gotest/case001/go.sum
+++ /dev/null
@@ -1,8 +0,0 @@
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/taosdata/driver-go v0.0.0-20210811072315-2cda9f1dc9ed h1:inSmPB0XSiyPZ6B66KnMsfyVVshH0mg2L0ld1b2aLtA=
-github.com/taosdata/driver-go v0.0.0-20210811072315-2cda9f1dc9ed/go.mod h1:k0UvvUy5mlSz4M+InxT3MZYO/eaTWXs7hO9ndLTeevU=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/tests/gotest/case002/case002.bat b/tests/gotest/case002/case002.bat
index ebec576e724ccb14319dd380c9783a783ac0db62..385677acae826e248a410472bfc7a022ff3003ab 100644
--- a/tests/gotest/case002/case002.bat
+++ b/tests/gotest/case002/case002.bat
@@ -1,5 +1,5 @@
@echo off
-echo ==== start run cases001.go
+echo ==== start run cases002.go
del go.*
go mod init demotest
diff --git a/tests/gotest/case002/case002.go b/tests/gotest/case002/case002.go
index c69da04cb271c24e33953ca8fdfea71c67349b4f..e2ba5ea28ee4f92cfbdca27c78d47268a387c693 100644
--- a/tests/gotest/case002/case002.go
+++ b/tests/gotest/case002/case002.go
@@ -43,10 +43,9 @@ func main() {
os.Exit(1)
}
defer db.Close()
- db.Exec("drop if exists database test")
- db.Exec("create if not exists database test")
+ db.Exec("drop database if exists test")
+ db.Exec("create database if not exists test ")
db.Exec("use test")
- db.Exec("drop if exists database test")
db.Exec("create table test (ts timestamp ,level int)")
for i := 0; i < 10; i++ {
sqlcmd := fmt.Sprintf("insert into test values(%d,%d)", ts+i, i)
diff --git a/tests/gotest/case002/case002.sh b/tests/gotest/case002/case002.sh
index 94e5bb44e03a1f7d2704752fcf9c080abcb4f23f..d98337cce7cfeb51ec9305226b20abdd7b360a46 100644
--- a/tests/gotest/case002/case002.sh
+++ b/tests/gotest/case002/case002.sh
@@ -1,6 +1,6 @@
#!/bin/bash
-echo "==== start run cases001.go"
+echo "==== start run cases002.go"
set +e
#set -x
diff --git a/tests/gotest/nanosupport/go.mod b/tests/gotest/nanosupport/go.mod
deleted file mode 100644
index 6b0a0021f394bdc40a77c24d37b07df969b1a541..0000000000000000000000000000000000000000
--- a/tests/gotest/nanosupport/go.mod
+++ /dev/null
@@ -1,5 +0,0 @@
-module taos
-
-go 1.16
-
-require github.com/taosdata/go-utils v0.0.0-20210811075537-2ce661ccb743
diff --git a/tests/gotest/nanosupport/go.sum b/tests/gotest/nanosupport/go.sum
deleted file mode 100644
index ef93bc6a0940ad371442bada008f0fa3c4acaf90..0000000000000000000000000000000000000000
--- a/tests/gotest/nanosupport/go.sum
+++ /dev/null
@@ -1,75 +0,0 @@
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/gin-contrib/cors v1.3.1/go.mod h1:jjEJ4268OPZUcU7k9Pm653S7lXUGcqMADzFA61xsmDk=
-github.com/gin-contrib/gzip v0.0.3/go.mod h1:YxxswVZIqOvcHEQpsSn+QF5guQtO1dCfy0shBPy4jFc=
-github.com/gin-contrib/pprof v1.3.0/go.mod h1:waMjT1H9b179t3CxuG1cV3DHpga6ybizwfBaM5OXaB0=
-github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
-github.com/gin-gonic/gin v1.5.0/go.mod h1:Nd6IXA8m5kNZdNEHMBd93KT+mdY3+bewLgRvmCsR2Do=
-github.com/gin-gonic/gin v1.6.2/go.mod h1:75u5sXoLsGZoRN5Sgbi1eraJ4GU3++wFwWzhwvtwp4M=
-github.com/gin-gonic/gin v1.6.3/go.mod h1:75u5sXoLsGZoRN5Sgbi1eraJ4GU3++wFwWzhwvtwp4M=
-github.com/gin-gonic/gin v1.7.2/go.mod h1:jD2toBW3GZUr5UMcdrwQA10I7RuaFOl/SGeDjXkfUtY=
-github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
-github.com/go-playground/locales v0.12.1/go.mod h1:IUMDtCfWo/w/mtMfIE/IG2K+Ey3ygWanZIBtBW0W2TM=
-github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8=
-github.com/go-playground/universal-translator v0.16.0/go.mod h1:1AnU7NaIRDWWzGEKwgtJRd2xk99HeFyHw3yid4rvQIY=
-github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA=
-github.com/go-playground/validator/v10 v10.2.0/go.mod h1:uOYAAleCW8F/7oMFd6aG0GOhaH6EGOAJShg8Id5JGkI=
-github.com/go-playground/validator/v10 v10.4.1/go.mod h1:nlOn6nFhuKACm19sB/8EGNn9GlaMV7XkbRSipzJ0Ii4=
-github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
-github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
-github.com/json-iterator/go v1.1.7/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
-github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
-github.com/json-iterator/go v1.1.11 h1:uVUAXhF2To8cbw/3xN3pxj6kk7TYKs98NIrTqPlMWAQ=
-github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
-github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/leodido/go-urn v1.1.0/go.mod h1:+cyI34gQWZcE1eQU7NVgKkkzdXDQHr1dBMtdAPozLkw=
-github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII=
-github.com/mattn/go-isatty v0.0.9/go.mod h1:YNRxwqDuOph6SZLI9vUUz6OYw3QyUt7WiY2yME+cCiQ=
-github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
-github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 h1:ZqeYNhU3OHLH3mGKHDcjJRFFRrJa6eAM5H+CtDdOsPc=
-github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
-github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742 h1:Esafd1046DLDQ0W1YjYsBW+p8U2u7vzgW2SQVmlNazg=
-github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
-github.com/panjf2000/ants/v2 v2.4.6 h1:drmj9mcygn2gawZ155dRbo+NfXEfAssjZNU1qoIb4gQ=
-github.com/panjf2000/ants/v2 v2.4.6/go.mod h1:f6F0NZVFsGCp5A7QW/Zj/m92atWwOkY0OIhFxRNFr4A=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/sirupsen/logrus v1.8.1 h1:dJKuHgqk1NNQlqoA6BTlM1Wf9DOH3NBjQyu0h9+AZZE=
-github.com/sirupsen/logrus v1.8.1/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/taosdata/driver-go v0.0.0-20210811072315-2cda9f1dc9ed h1:inSmPB0XSiyPZ6B66KnMsfyVVshH0mg2L0ld1b2aLtA=
-github.com/taosdata/driver-go v0.0.0-20210811072315-2cda9f1dc9ed/go.mod h1:k0UvvUy5mlSz4M+InxT3MZYO/eaTWXs7hO9ndLTeevU=
-github.com/taosdata/go-utils v0.0.0-20210811075537-2ce661ccb743 h1:w90OkSLXv4d7uEcU8fH70pB5tawNYYZ1qjhDfg7oFTQ=
-github.com/taosdata/go-utils v0.0.0-20210811075537-2ce661ccb743/go.mod h1:WRQlPHYbVvsRmtIDJ4GS31BbiTQnFHFdhh0XpLavTIg=
-github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw=
-github.com/ugorji/go/codec v1.1.7/go.mod h1:Ax+UKWsSmolVDwsd+7N3ZtXu+yMGCf907BLYF3GoBXY=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200116001909-b77594299b42 h1:vEOn+mP2zCOVzKckCZy6YsCtDblrpj/w7B9nxGNELpg=
-golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/go-playground/assert.v1 v1.2.1/go.mod h1:9RXL0bg/zibRAgZUYszZSwO/z8Y/a8bDuhia5mkpMnE=
-gopkg.in/go-playground/validator.v9 v9.29.1/go.mod h1:+c9/zcJMFNgbLvly1L1V+PpxWdVbfP1avr/N00E2vyQ=
-gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.7/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/tests/gotest/nanosupport/nanoCase.bat b/tests/gotest/nanosupport/nanoCase.bat
new file mode 100644
index 0000000000000000000000000000000000000000..86bddd5b02c5399d5b8d70bd08020e96a7d1c0e5
--- /dev/null
+++ b/tests/gotest/nanosupport/nanoCase.bat
@@ -0,0 +1,9 @@
+@echo off
+echo ==== start run nanosupport.go
+
+del go.*
+go mod init nano
+go mod tidy
+go build
+nano.exe -h %1 -p %2
+cd ..
diff --git a/tests/gotest/nanosupport/nanoCase.sh b/tests/gotest/nanosupport/nanoCase.sh
new file mode 100644
index 0000000000000000000000000000000000000000..bec8929f14c0a56e7c4074efa39d1e1e881fb12e
--- /dev/null
+++ b/tests/gotest/nanosupport/nanoCase.sh
@@ -0,0 +1,22 @@
+#!/bin/bash
+
+echo "==== start run nanosupport.go "
+
+set +e
+#set -x
+
+script_dir="$(dirname $(readlink -f $0))"
+#echo "pwd: $script_dir, para0: $0"
+
+#execName=$0
+#execName=`echo ${execName##*/}`
+#goName=`echo ${execName%.*}`
+
+###### step 3: start build
+cd $script_dir
+rm -f go.*
+go mod init nano
+go mod tidy
+go build
+sleep 10s
+./nano -h $1 -p $2
diff --git a/tests/gotest/nanosupport/main.go b/tests/gotest/nanosupport/nanosupport.go
similarity index 99%
rename from tests/gotest/nanosupport/main.go
rename to tests/gotest/nanosupport/nanosupport.go
index c5440c81f6c6708be227c36e52a1a4747a2e3011..e2f24a73c0a6db3c94b90879c73d0f05e2476307 100644
--- a/tests/gotest/nanosupport/main.go
+++ b/tests/gotest/nanosupport/nanosupport.go
@@ -3,7 +3,7 @@ package main
import (
"fmt"
"log"
- "taos/connector"
+ "nano/connector"
"time"
"github.com/taosdata/go-utils/tdengine/config"
diff --git a/tests/perftest-scripts/perftest-query.sh b/tests/perftest-scripts/perftest-query.sh
index 68b64fd4e0c4f09ff0b8e96d7802b954b774fbc5..05b2d45ce434d0990d7c143863b9ca268a7d6a26 100755
--- a/tests/perftest-scripts/perftest-query.sh
+++ b/tests/perftest-scripts/perftest-query.sh
@@ -21,7 +21,8 @@ fi
today=`date +"%Y%m%d"`
WORK_DIR=/root/pxiao
-PERFORMANCE_TEST_REPORT=$WORK_DIR/TDengine/tests/performance-report-$branch-$type-$today.log
+name=`echo $branch | cut -d '/' -f2`
+PERFORMANCE_TEST_REPORT=$WORK_DIR/TDinternal/community/tests/performance-report-$name-$type-$today.log
# Coloured Echoes #
function red_echo { echo -e "\033[31m$@\033[0m"; } #
@@ -54,11 +55,12 @@ function stopTaosd {
}
function buildTDengine {
- echoInfo "Build TDengine"
- cd $WORK_DIR/TDengine
+ echoInfo "Build TDinternal"
+ cd $WORK_DIR/TDinternal
git remote update > /dev/null
git reset --hard HEAD
+ git fetch
git checkout $branch
REMOTE_COMMIT=`git rev-parse --short remotes/origin/$branch`
LOCAL_COMMIT=`git rev-parse --short @`
@@ -69,13 +71,22 @@ function buildTDengine {
echo "repo up-to-date"
fi
+ cd community
+ git reset --hard HEAD
+ cd ..
+ echo "git submodule update --init --recursive"
+ git submodule update --init --recursive
+
git pull > /dev/null 2>&1
- if [ $type = "jemalloc" ];then
- echo "git submodule update --init --recursive"
- git submodule update --init --recursive
- fi
+
+ cd community
+ git remote update > /dev/null
+ git reset --hard HEAD
+ git fetch
+ git checkout $branch
+ REMOTE_COMMIT=`git rev-parse --short remotes/origin/$branch`
LOCAL_COMMIT=`git rev-parse --short @`
- cd debug
+ cd ../debug
rm -rf *
if [ $type = "jemalloc" ];then
echo "cmake .. -DJEMALLOC_ENABLED=true > /dev/null"
@@ -83,6 +94,10 @@ function buildTDengine {
else
cmake .. > /dev/null
fi
+ #cp $WORK_DIR/taosdemoPerformance.py $WORK_DIR/TDinternal/community/tests/pytest/tools/
+ #cp $WORK_DIR/insertFromCSVPerformance.py $WORK_DIR/TDinternal/community/tests/pytest/insert/
+ #cp $WORK_DIR/queryPerformance.py $WORK_DIR/TDinternal/community/tests/pytest/query/
+ rm -rf $WORK_DIR/TDinternal/community/tests/pytest/query/operator.py
make > /dev/null 2>&1
make install > /dev/null 2>&1
echo "Build TDengine on remote server"
@@ -91,24 +106,24 @@ function buildTDengine {
function runQueryPerfTest {
[ -f $PERFORMANCE_TEST_REPORT ] && rm $PERFORMANCE_TEST_REPORT
- nohup $WORK_DIR/TDengine/debug/build/bin/taosd -c /etc/perf/ > /dev/null 2>&1 &
+ nohup $WORK_DIR/TDinternal/debug/build/bin/taosd -c /etc/perf/ > /dev/null 2>&1 &
echoInfo "Wait TDengine to start"
sleep 60
echoInfo "Run Performance Test"
- cd $WORK_DIR/TDengine/tests/pytest
+ cd $WORK_DIR/TDinternal/community/tests/pytest
- python3 query/queryPerformance.py -c $LOCAL_COMMIT -b $branch -T $type | tee -a $PERFORMANCE_TEST_REPORT
+ python3 query/queryPerformance.py -c $LOCAL_COMMIT -b $branch -T $type -d perf2 | tee -a $PERFORMANCE_TEST_REPORT
python3 insert/insertFromCSVPerformance.py -c $LOCAL_COMMIT -b $branch -T $type | tee -a $PERFORMANCE_TEST_REPORT
echo "=========== taosdemo performance: 4 int columns, 10000 tables, 100000 recoreds per table ===========" | tee -a $PERFORMANCE_TEST_REPORT
python3 tools/taosdemoPerformance.py -c $LOCAL_COMMIT -b $branch -T $type | tee -a $PERFORMANCE_TEST_REPORT
- echo "=========== taosdemo performance: 400 int columns, 400 double columns, 200 binary(128) columns, 10000 tables, 1000 recoreds per table ===========" | tee -a $PERFORMANCE_TEST_REPORT
- python3 tools/taosdemoPerformance.py -c $LOCAL_COMMIT -b $branch -T $type -i 400 -D 400 -B 200 -t 10000 -r 100 | tee -a $PERFORMANCE_TEST_REPORT
+ echo "=========== taosdemo performance: 400 int columns, 400 double columns, 200 binary(128) columns, 10000 tables, 10 recoreds per table ===========" | tee -a $PERFORMANCE_TEST_REPORT
+ python3 tools/taosdemoPerformance.py -c $LOCAL_COMMIT -b $branch -T $type -i 400 -D 400 -B 200 -t 10000 -r 10 | tee -a $PERFORMANCE_TEST_REPORT
- echo "=========== taosdemo performance: 1900 int columns, 1900 double columns, 200 binary(128) columns, 10000 tables, 1000 recoreds per table ===========" | tee -a $PERFORMANCE_TEST_REPORT
- python3 tools/taosdemoPerformance.py -c $LOCAL_COMMIT -b $branch -T $type -i 1900 -D 1900 -B 200 -t 10000 -r 100 | tee -a $PERFORMANCE_TEST_REPORT
+ echo "=========== taosdemo performance: 1900 int columns, 1900 double columns, 200 binary(128) columns, 10000 tables, 10 recoreds per table ===========" | tee -a $PERFORMANCE_TEST_REPORT
+ python3 tools/taosdemoPerformance.py -c $LOCAL_COMMIT -b $branch -T $type -i 1900 -D 1900 -B 200 -t 10000 -r 10 | tee -a $PERFORMANCE_TEST_REPORT
}
@@ -121,7 +136,7 @@ function sendReport {
sed -i 's/\x1b\[[0-9;]*m//g' $PERFORMANCE_TEST_REPORT
BODY_CONTENT=`cat $PERFORMANCE_TEST_REPORT`
- echo -e "From: \nto: ${receiver}\nsubject: Query Performace Report ${branch} ${jemalloc} commit ID: ${LOCAL_COMMIT}\n\n${today}:\n${BODY_CONTENT}" | \
+ echo -e "From: \nto: ${receiver}\nsubject: Query Performace Report ${branch} ${type} commit ID: ${LOCAL_COMMIT}\n\n${today}:\n${BODY_CONTENT}" | \
(cat - && uuencode $PERFORMANCE_TEST_REPORT performance-test-report-$today.log) | \
/usr/sbin/ssmtp "${receiver}" && echo "Report Sent!"
}
diff --git a/tests/pytest/nanosupport/nanosupportTestCase.py b/tests/pytest/dbmgmt/nanoSecondCheck.py
similarity index 82%
rename from tests/pytest/nanosupport/nanosupportTestCase.py
rename to tests/pytest/dbmgmt/nanoSecondCheck.py
index 0645814576b448418ee02c332b929b8a1b1806db..a5e9adacee53a9172a2d8990ccc4d83feb983bdd 100644
--- a/tests/pytest/nanosupport/nanosupportTestCase.py
+++ b/tests/pytest/dbmgmt/nanoSecondCheck.py
@@ -1,4 +1,3 @@
-
# #################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved.
@@ -21,7 +20,7 @@ from util.sql import *
import time
from datetime import datetime
import os
-import datetime
+
class TDTestCase:
def init(self, conn, logSql):
@@ -209,43 +208,6 @@ class TDTestCase:
tdSql.query('select * from tb3 where ts = \'2021-06-10 0:00:00.123456789\';')
tdSql.checkRows(1)
- # check timezone support
- tdSql.execute('drop database if exists nsdb;')
- tdSql.execute('create database nsdb precision "ns";')
- tdSql.execute('use nsdb;')
- tdSql.execute('create stable st (ts timestamp ,speed float ) tags(time timestamp ,id int);')
- tdSql.execute('insert into tb1 using st tags("2021-06-10 0:00:00.123456789" , 1 ) values("2021-06-10T0:00:00.123456789+07:00" , 1.0);' )
- tdSql.query("select first(*) from tb1;")
- res = tdSql.getResult("select first(*) from tb1;")
- tdSql.checkData(0,0,1623258000123456789)
- tdSql.execute('insert into tb1 using st tags("2021-06-10 0:00:00.123456789" , 1 ) values("2021-06-10T0:00:00.123456789+06:00" , 2.0);' )
- tdSql.query("select last(*) from tb1;")
-
-
-
- tdSql.execute('create database usdb precision "us";')
- tdSql.execute('use usdb;')
- tdSql.execute('create stable st (ts timestamp ,speed float ) tags(time timestamp ,id int);')
- tdSql.execute('insert into tb1 using st tags("2021-06-10 0:00:00.123456" , 1 ) values("2021-06-10T0:00:00.123456+07:00" , 1.0);' )
- res = tdSql.getResult("select first(*) from tb1;")
- print(res)
- if res == [(datetime.datetime(2021, 6, 10, 1, 0, 0, 123456), 1.0)]:
- tdLog.info('check timezone pass about us database')
-
- tdSql.execute('drop database if exists msdb;')
- tdSql.execute('create database msdb precision "ms";')
- tdSql.execute('use msdb;')
- tdSql.execute('create stable st (ts timestamp ,speed float ) tags(time timestamp ,id int);')
- tdSql.execute('insert into tb1 using st tags("2021-06-10 0:00:00.123" , 1 ) values("2021-06-10T0:00:00.123+07:00" , 1.0);' )
- res = tdSql.getResult("select first(*) from tb1;")
- print(res)
- if res ==[(datetime.datetime(2021, 6, 10, 1, 0, 0, 123000), 1.0)]:
- tdLog.info('check timezone pass about ms database')
-
-
- os.system('rm -rf ./*.py.sql')
-
-
os.system('sudo timedatectl set-ntp on')
def stop(self):
@@ -254,4 +216,4 @@ class TDTestCase:
tdCases.addWindows(__file__, TDTestCase())
-tdCases.addLinux(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())
\ No newline at end of file
diff --git a/tests/pytest/fulltest.sh b/tests/pytest/fulltest.sh
index ca837f54e0f22276304b5d05b89f86cab06d47c6..06ec3c6bfabfe4d9c378c9d17dda944990f624a8 100755
--- a/tests/pytest/fulltest.sh
+++ b/tests/pytest/fulltest.sh
@@ -13,7 +13,6 @@ python3 ./test.py -f insert/tinyint.py
python3 ./test.py -f insert/date.py
python3 ./test.py -f insert/binary.py
python3 ./test.py -f insert/nchar.py
-
#python3 ./test.py -f insert/nchar-boundary.py
python3 ./test.py -f insert/nchar-unicode.py
python3 ./test.py -f insert/multi.py
@@ -83,9 +82,8 @@ python3 ./test.py -f tag_lite/tinyint.py
python3 ./test.py -f tag_lite/timestamp.py
python3 ./test.py -f tag_lite/TestModifyTag.py
-
-#nano support test
-python3 test.py -f nanosupport/nanosupportTestCase.py
+#python3 ./test.py -f dbmgmt/database-name-boundary.py
+python3 test.py -f dbmgmt/nanoSecondCheck.py
python3 ./test.py -f import_merge/importBlock1HO.py
python3 ./test.py -f import_merge/importBlock1HPO.py
diff --git a/tests/pytest/functions/showOfflineThresholdIs864000.py b/tests/pytest/functions/showOfflineThresholdIs864000.py
index 8ec25cef26b3c97bc55f2f4df3fe8cf55a19125c..7462d4cd72f600674fcb82aa1224019787d23fd5 100644
--- a/tests/pytest/functions/showOfflineThresholdIs864000.py
+++ b/tests/pytest/functions/showOfflineThresholdIs864000.py
@@ -12,6 +12,8 @@
# -*- coding: utf-8 -*-
import sys
+import numpy as np
+
from util.log import *
from util.cases import *
from util.sql import *
@@ -24,8 +26,17 @@ class TDTestCase:
tdSql.init(conn.cursor(), logSql)
def run(self):
+ # tdSql.query("show variables")
+ # tdSql.checkData(54, 1, 864000)
+ tdSql.execute("show variables")
+ res = tdSql.cursor.fetchall()
+ resList = np.array(res)
+ index = np.where(resList == "offlineThreshold")
+ index_value = np.dstack((index[0])).squeeze()
tdSql.query("show variables")
- tdSql.checkData(55, 1, 864000)
+ tdSql.checkData(index_value, 1, 864000)
+ pass
+
def stop(self):
tdSql.close()
diff --git a/tests/pytest/insert/insertTelnetLines.py b/tests/pytest/insert/insertTelnetLines.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ebb6bd3df4bcd4abfbb8c42cf5024fe066fcce3
--- /dev/null
+++ b/tests/pytest/insert/insertTelnetLines.py
@@ -0,0 +1,313 @@
+###################################################################
+# Copyright (c) 2021 by TAOS Technologies, Inc.
+# All rights reserved.
+#
+# This file is proprietary and confidential to TAOS Technologies.
+# No part of this file may be reproduced, stored, transmitted,
+# disclosed or used in any form or by any means other than as
+# expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+from util.log import *
+from util.cases import *
+from util.sql import *
+
+
+class TDTestCase:
+ def init(self, conn, logSql):
+ tdLog.debug("start to execute %s" % __file__)
+ tdSql.init(conn.cursor(), logSql)
+ self._conn = conn
+
+ def run(self):
+ print("running {}".format(__file__))
+ tdSql.execute("drop database if exists test")
+ tdSql.execute("create database if not exists test precision 'us'")
+ tdSql.execute('use test')
+
+
+ ### metric ###
+ print("============= step1 : test metric ================")
+ lines0 = [
+ "stb0_0 1626006833639000000ns 4i8 host=\"host0\",interface=\"eth0\"",
+ "stb0_1 1626006833639000000ns 4i8 host=\"host0\",interface=\"eth0\"",
+ "stb0_2 1626006833639000000ns 4i8 host=\"host0\",interface=\"eth0\"",
+ ]
+
+ code = self._conn.insert_telnet_lines(lines0)
+ print("insert_telnet_lines result {}".format(code))
+
+ tdSql.query("show stables")
+ tdSql.checkRows(3)
+
+ tdSql.query("describe stb0_0")
+ tdSql.checkRows(4)
+
+ tdSql.query("describe stb0_1")
+ tdSql.checkRows(4)
+
+ tdSql.query("describe stb0_2")
+ tdSql.checkRows(4)
+
+ ### timestamp ###
+ print("============= step2 : test timestamp ================")
+ lines1 = [
+ "stb1 1626006833s 1i8 host=\"host0\"",
+ "stb1 1626006833639000000ns 2i8 host=\"host0\"",
+ "stb1 1626006833640000us 3i8 host=\"host0\"",
+ "stb1 1626006833641123 4i8 host=\"host0\"",
+ "stb1 1626006833651ms 5i8 host=\"host0\"",
+ "stb1 0 6i8 host=\"host0\"",
+ ]
+
+ code = self._conn.insert_telnet_lines(lines1)
+ print("insert_telnet_lines result {}".format(code))
+
+ tdSql.query("select * from stb1")
+ tdSql.checkRows(6)
+
+ ### metric value ###
+ print("============= step3 : test metric value ================")
+
+ #tinyint
+ lines2_0 = [
+ "stb2_0 1626006833651ms -127i8 host=\"host0\"",
+ "stb2_0 1626006833652ms 127i8 host=\"host0\""
+ ]
+ code = self._conn.insert_telnet_lines(lines2_0)
+ print("insert_telnet_lines result {}".format(code))
+
+ tdSql.query("select * from stb2_0")
+ tdSql.checkRows(2)
+
+ tdSql.query("describe stb2_0")
+ tdSql.checkRows(3)
+ tdSql.checkData(1, 1, "TINYINT")
+
+ #smallint
+ lines2_1 = [
+ "stb2_1 1626006833651ms -32767i16 host=\"host0\"",
+ "stb2_1 1626006833652ms 32767i16 host=\"host0\""
+ ]
+ code = self._conn.insert_telnet_lines(lines2_1)
+ print("insert_telnet_lines result {}".format(code))
+
+ tdSql.query("select * from stb2_1")
+ tdSql.checkRows(2)
+
+ tdSql.query("describe stb2_1")
+ tdSql.checkRows(3)
+ tdSql.checkData(1, 1, "SMALLINT")
+
+ #int
+ lines2_2 = [
+ "stb2_2 1626006833651ms -2147483647i32 host=\"host0\"",
+ "stb2_2 1626006833652ms 2147483647i32 host=\"host0\""
+ ]
+
+ code = self._conn.insert_telnet_lines(lines2_2)
+ print("insert_telnet_lines result {}".format(code))
+
+ tdSql.query("select * from stb2_2")
+ tdSql.checkRows(2)
+
+ tdSql.query("describe stb2_2")
+ tdSql.checkRows(3)
+ tdSql.checkData(1, 1, "INT")
+
+ #bigint
+ lines2_3 = [
+ "stb2_3 1626006833651ms -9223372036854775807i64 host=\"host0\"",
+ "stb2_3 1626006833652ms 9223372036854775807i64 host=\"host0\""
+ ]
+
+ code = self._conn.insert_telnet_lines(lines2_3)
+ print("insert_telnet_lines result {}".format(code))
+
+ tdSql.query("select * from stb2_3")
+ tdSql.checkRows(2)
+
+ tdSql.query("describe stb2_3")
+ tdSql.checkRows(3)
+ tdSql.checkData(1, 1, "BIGINT")
+
+ #float
+ lines2_4 = [
+ "stb2_4 1626006833610ms 3f32 host=\"host0\"",
+ "stb2_4 1626006833620ms -3f32 host=\"host0\"",
+ "stb2_4 1626006833630ms 3.4f32 host=\"host0\"",
+ "stb2_4 1626006833640ms -3.4f32 host=\"host0\"",
+ "stb2_4 1626006833650ms 3.4E10f32 host=\"host0\"",
+ "stb2_4 1626006833660ms -3.4e10f32 host=\"host0\"",
+ "stb2_4 1626006833670ms 3.4E+2f32 host=\"host0\"",
+ "stb2_4 1626006833680ms -3.4e-2f32 host=\"host0\"",
+ "stb2_4 1626006833690ms 3.15 host=\"host0\"",
+ "stb2_4 1626006833700ms 3.4E38f32 host=\"host0\"",
+ "stb2_4 1626006833710ms -3.4E38f32 host=\"host0\""
+ ]
+
+ code = self._conn.insert_telnet_lines(lines2_4)
+ print("insert_telnet_lines result {}".format(code))
+
+ tdSql.query("select * from stb2_4")
+ tdSql.checkRows(11)
+
+ tdSql.query("describe stb2_4")
+ tdSql.checkRows(3)
+ tdSql.checkData(1, 1, "FLOAT")
+
+ #double
+ lines2_5 = [
+ "stb2_5 1626006833610ms 3f64 host=\"host0\"",
+ "stb2_5 1626006833620ms -3f64 host=\"host0\"",
+ "stb2_5 1626006833630ms 3.4f64 host=\"host0\"",
+ "stb2_5 1626006833640ms -3.4f64 host=\"host0\"",
+ "stb2_5 1626006833650ms 3.4E10f64 host=\"host0\"",
+ "stb2_5 1626006833660ms -3.4e10f64 host=\"host0\"",
+ "stb2_5 1626006833670ms 3.4E+2f64 host=\"host0\"",
+ "stb2_5 1626006833680ms -3.4e-2f64 host=\"host0\"",
+ "stb2_5 1626006833690ms 1.7E308f64 host=\"host0\"",
+ "stb2_5 1626006833700ms -1.7E308f64 host=\"host0\""
+ ]
+
+ code = self._conn.insert_telnet_lines(lines2_5)
+ print("insert_telnet_lines result {}".format(code))
+
+ tdSql.query("select * from stb2_5")
+ tdSql.checkRows(10)
+
+ tdSql.query("describe stb2_5")
+ tdSql.checkRows(3)
+ tdSql.checkData(1, 1, "DOUBLE")
+
+ #bool
+ lines2_6 = [
+ "stb2_6 1626006833610ms t host=\"host0\"",
+ "stb2_6 1626006833620ms T host=\"host0\"",
+ "stb2_6 1626006833630ms true host=\"host0\"",
+ "stb2_6 1626006833640ms True host=\"host0\"",
+ "stb2_6 1626006833650ms TRUE host=\"host0\"",
+ "stb2_6 1626006833660ms f host=\"host0\"",
+ "stb2_6 1626006833670ms F host=\"host0\"",
+ "stb2_6 1626006833680ms false host=\"host0\"",
+ "stb2_6 1626006833690ms False host=\"host0\"",
+ "stb2_6 1626006833700ms FALSE host=\"host0\""
+ ]
+
+ code = self._conn.insert_telnet_lines(lines2_6)
+ print("insert_telnet_lines result {}".format(code))
+
+ tdSql.query("select * from stb2_6")
+ tdSql.checkRows(10)
+
+ tdSql.query("describe stb2_6")
+ tdSql.checkRows(3)
+ tdSql.checkData(1, 1, "BOOL")
+
+ #binary
+ lines2_7 = [
+ "stb2_7 1626006833610ms \"binary_val.!@#$%^&*\" host=\"host0\"",
+ "stb2_7 1626006833620ms \"binary_val.:;,./?|+-=\" host=\"host0\"",
+ "stb2_7 1626006833630ms \"binary_val.()[]{}<>\" host=\"host0\""
+ ]
+
+ code = self._conn.insert_telnet_lines(lines2_7)
+ print("insert_telnet_lines result {}".format(code))
+
+ tdSql.query("select * from stb2_7")
+ tdSql.checkRows(3)
+
+ tdSql.query("describe stb2_7")
+ tdSql.checkRows(3)
+ tdSql.checkData(1, 1, "BINARY")
+
+ #nchar
+ lines2_8 = [
+ "stb2_8 1626006833610ms L\"nchar_val数值一\" host=\"host0\"",
+ "stb2_8 1626006833620ms L\"nchar_val数值二\" host=\"host0\""
+ ]
+
+ code = self._conn.insert_telnet_lines(lines2_8)
+ print("insert_telnet_lines result {}".format(code))
+
+ tdSql.query("select * from stb2_8")
+ tdSql.checkRows(2)
+
+ tdSql.query("describe stb2_8")
+ tdSql.checkRows(3)
+ tdSql.checkData(1, 1, "NCHAR")
+
+ ### tags ###
+ print("============= step3 : test tags ================")
+ #tag value types
+ lines3_0 = [
+ "stb3_0 1626006833610ms 1 t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=3.4E38f32,t6=1.7E308f64,t7=true,t8=\"binary_val_1\",t9=L\"标签值1\"",
+ "stb3_0 1626006833610ms 2 t1=-127i8,t2=-32767i16,t3=-2147483647i32,t4=-9223372036854775807i64,t5=-3.4E38f32,t6=-1.7E308f64,t7=false,t8=\"binary_val_2\",t9=L\"标签值2\""
+ ]
+
+ code = self._conn.insert_telnet_lines(lines3_0)
+ print("insert_telnet_lines result {}".format(code))
+
+ tdSql.query("select * from stb3_0")
+ tdSql.checkRows(2)
+
+ tdSql.query("describe stb3_0")
+ tdSql.checkRows(11)
+
+ tdSql.checkData(2, 1, "TINYINT")
+ tdSql.checkData(2, 3, "TAG")
+
+ tdSql.checkData(3, 1, "SMALLINT")
+ tdSql.checkData(3, 3, "TAG")
+
+ tdSql.checkData(4, 1, "INT")
+ tdSql.checkData(4, 3, "TAG")
+
+ tdSql.checkData(5, 1, "BIGINT")
+ tdSql.checkData(5, 3, "TAG")
+
+ tdSql.checkData(6, 1, "FLOAT")
+ tdSql.checkData(6, 3, "TAG")
+
+ tdSql.checkData(7, 1, "DOUBLE")
+ tdSql.checkData(7, 3, "TAG")
+
+ tdSql.checkData(8, 1, "BOOL")
+ tdSql.checkData(8, 3, "TAG")
+
+ tdSql.checkData(9, 1, "BINARY")
+ tdSql.checkData(9, 3, "TAG")
+
+ tdSql.checkData(10, 1, "NCHAR")
+ tdSql.checkData(10, 3, "TAG")
+
+
+ #tag ID as child table name
+ lines3_1 = [
+ "stb3_1 1626006833610ms 1 id=\"child_table1\",host=\"host1\"",
+ "stb3_1 1626006833610ms 2 host=\"host2\",iD=\"child_table2\"",
+ "stb3_1 1626006833610ms 3 ID=\"child_table3\",host=\"host3\""
+ ]
+
+ code = self._conn.insert_telnet_lines(lines3_1)
+ print("insert_telnet_lines result {}".format(code))
+
+ tdSql.query("select * from stb3_1")
+ tdSql.checkRows(3)
+
+ tdSql.query("show tables like \"child%\"")
+ tdSql.checkRows(3)
+
+ tdSql.checkData(0, 0, "child_table1")
+
+ def stop(self):
+ tdSql.close()
+ tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())
diff --git a/tests/pytest/insert/openTsdbTelnetLinesInsert.py b/tests/pytest/insert/openTsdbTelnetLinesInsert.py
new file mode 100644
index 0000000000000000000000000000000000000000..e0d1c0d9669e77e236d4b1591b302a717c5a93d1
--- /dev/null
+++ b/tests/pytest/insert/openTsdbTelnetLinesInsert.py
@@ -0,0 +1,1308 @@
+###################################################################
+# Copyright (c) 2021 by TAOS Technologies, Inc.
+# All rights reserved.
+#
+# This file is proprietary and confidential to TAOS Technologies.
+# No part of this file may be reproduced, stored, transmitted,
+# disclosed or used in any form or by any means other than as
+# expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import traceback
+import random
+import string
+from taos.error import LinesError
+import time
+from copy import deepcopy
+import numpy as np
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.common import tdCom
+import threading
+
+
+class TDTestCase:
+ def init(self, conn, logSql):
+ tdLog.debug("start to execute %s" % __file__)
+ tdSql.init(conn.cursor(), logSql)
+ self._conn = conn
+
+ def createDb(self, name="test", db_update_tag=0):
+ if db_update_tag == 0:
+ tdSql.execute(f"drop database if exists {name}")
+ tdSql.execute(f"create database if not exists {name} precision 'us'")
+ else:
+ tdSql.execute(f"drop database if exists {name}")
+ tdSql.execute(f"create database if not exists {name} precision 'us' update 1")
+ tdSql.execute(f'use {name}')
+
+ def timeTrans(self, time_value):
+ if time_value.endswith("ns"):
+ ts = int(''.join(list(filter(str.isdigit, time_value))))/1000000000
+ elif time_value.endswith("us") or time_value.isdigit() and int(time_value) != 0:
+ ts = int(''.join(list(filter(str.isdigit, time_value))))/1000000
+ elif time_value.endswith("ms"):
+ ts = int(''.join(list(filter(str.isdigit, time_value))))/1000
+ elif time_value.endswith("s") and list(time_value)[-1] not in "num":
+ ts = int(''.join(list(filter(str.isdigit, time_value))))/1
+ elif int(time_value) == 0:
+ ts = time.time()
+ else:
+ print("input ts maybe not right format")
+ ulsec = repr(ts).split('.')[1][:6]
+ if len(ulsec) < 6 and int(ulsec) != 0:
+ ulsec = int(ulsec) * (10 ** (6 - len(ulsec)))
+ elif int(ulsec) == 0:
+ ulsec *= 6
+ # * follow two rows added for tsCheckCase
+ td_ts = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(ts))
+ return td_ts
+ #td_ts = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(ts))
+ td_ts = time.strftime("%Y-%m-%d %H:%M:%S.{}".format(ulsec), time.localtime(ts))
+ return td_ts
+ #return repr(datetime.datetime.strptime(td_ts, "%Y-%m-%d %H:%M:%S.%f"))
+
+ def dateToTs(self, datetime_input):
+ return int(time.mktime(time.strptime(datetime_input, "%Y-%m-%d %H:%M:%S.%f")))
+
+ def getTdTypeValue(self, value):
+ if value.endswith("i8"):
+ td_type = "TINYINT"
+ td_tag_value = ''.join(list(value)[:-2])
+ elif value.endswith("i16"):
+ td_type = "SMALLINT"
+ td_tag_value = ''.join(list(value)[:-3])
+ elif value.endswith("i32"):
+ td_type = "INT"
+ td_tag_value = ''.join(list(value)[:-3])
+ elif value.endswith("i64"):
+ td_type = "BIGINT"
+ td_tag_value = ''.join(list(value)[:-3])
+ elif value.endswith("u64"):
+ td_type = "BIGINT UNSIGNED"
+ td_tag_value = ''.join(list(value)[:-3])
+ elif value.endswith("f32"):
+ td_type = "FLOAT"
+ td_tag_value = ''.join(list(value)[:-3])
+ td_tag_value = '{}'.format(np.float32(td_tag_value))
+ elif value.endswith("f64"):
+ td_type = "DOUBLE"
+ td_tag_value = ''.join(list(value)[:-3])
+ elif value.startswith('L"'):
+ td_type = "NCHAR"
+ td_tag_value = ''.join(list(value)[2:-1])
+ elif value.startswith('"') and value.endswith('"'):
+ td_type = "BINARY"
+ td_tag_value = ''.join(list(value)[1:-1])
+ elif value.lower() == "t" or value == "true" or value == "True" or value == "TRUE":
+ td_type = "BOOL"
+ td_tag_value = "True"
+ elif value.lower() == "f" or value == "false" or value == "False" or value == "FALSE":
+ td_type = "BOOL"
+ td_tag_value = "False"
+ else:
+ td_type = "FLOAT"
+ td_tag_value = value
+ return td_type, td_tag_value
+
+ def typeTrans(self, type_list):
+ type_num_list = []
+ for tp in type_list:
+ if tp.upper() == "TIMESTAMP":
+ type_num_list.append(9)
+ elif tp.upper() == "BOOL":
+ type_num_list.append(1)
+ elif tp.upper() == "TINYINT":
+ type_num_list.append(2)
+ elif tp.upper() == "SMALLINT":
+ type_num_list.append(3)
+ elif tp.upper() == "INT":
+ type_num_list.append(4)
+ elif tp.upper() == "BIGINT":
+ type_num_list.append(5)
+ elif tp.upper() == "FLOAT":
+ type_num_list.append(6)
+ elif tp.upper() == "DOUBLE":
+ type_num_list.append(7)
+ elif tp.upper() == "BINARY":
+ type_num_list.append(8)
+ elif tp.upper() == "NCHAR":
+ type_num_list.append(10)
+ elif tp.upper() == "BIGINT UNSIGNED":
+ type_num_list.append(14)
+ return type_num_list
+
+ def inputHandle(self, input_sql):
+ input_sql_split_list = input_sql.split(" ")
+ stb_name = input_sql_split_list[0]
+
+ #'stb2_5 1626006833610ms 3f64 host="host0"',
+ stb_tag_list = input_sql_split_list[3].split(',')
+ stb_col_value = input_sql_split_list[2]
+ ts_value = self.timeTrans(input_sql_split_list[1])
+
+ tag_name_list = []
+ tag_value_list = []
+ td_tag_value_list = []
+ td_tag_type_list = []
+
+ col_name_list = []
+ col_value_list = []
+ td_col_value_list = []
+ td_col_type_list = []
+
+ for elm in stb_tag_list:
+ if "id=" in elm.lower():
+ tb_name = elm.split('=')[1]
+ else:
+ tag_name_list.append(elm.split("=")[0])
+ tag_value_list.append(elm.split("=")[1])
+ tb_name = ""
+ td_tag_value_list.append(self.getTdTypeValue(elm.split("=")[1])[1])
+ td_tag_type_list.append(self.getTdTypeValue(elm.split("=")[1])[0])
+
+ col_name_list.append('value')
+ col_value_list.append(stb_col_value)
+
+ td_col_value_list.append(self.getTdTypeValue(stb_col_value)[1])
+ td_col_type_list.append(self.getTdTypeValue(stb_col_value)[0])
+
+ final_field_list = []
+ final_field_list.extend(col_name_list)
+ final_field_list.extend(tag_name_list)
+
+ final_type_list = []
+ final_type_list.append("TIMESTAMP")
+ final_type_list.extend(td_col_type_list)
+ final_type_list.extend(td_tag_type_list)
+ final_type_list = self.typeTrans(final_type_list)
+
+ final_value_list = []
+ final_value_list.append(ts_value)
+ final_value_list.extend(td_col_value_list)
+ final_value_list.extend(td_tag_value_list)
+ return final_value_list, final_field_list, final_type_list, stb_name, tb_name
+
+ def genFullTypeSql(self, stb_name="", tb_name="", value="", t0="", t1="127i8", t2="32767i16", t3="2147483647i32",
+ t4="9223372036854775807i64", t5="11.12345f32", t6="22.123456789f64", t7="\"binaryTagValue\"",
+ t8="L\"ncharTagValue\"", ts="1626006833639000000ns",
+ id_noexist_tag=None, id_change_tag=None, id_upper_tag=None, id_double_tag=None,
+ t_add_tag=None, t_mul_tag=None, t_multi_tag=None, t_blank_tag=None):
+ if stb_name == "":
+ stb_name = tdCom.getLongName(len=6, mode="letters")
+ if tb_name == "":
+ tb_name = f'{stb_name}_{random.randint(0, 65535)}_{random.randint(0, 65535)}'
+ if t0 == "":
+ t0 = random.choice(["f", "F", "false", "False", "t", "T", "true", "True", "TRUE", "FALSE"])
+ if value == "":
+ value = random.choice(["f", "F", "false", "False", "t", "T", "true", "True", "TRUE", "FALSE"])
+ if id_upper_tag is not None:
+ id = "ID"
+ else:
+ id = "id"
+ sql_seq = f'{stb_name} {ts} {value} {id}=\"{tb_name}\",t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6},t7={t7},t8={t8}'
+ if id_noexist_tag is not None:
+ sql_seq = f'{stb_name} {ts} {value} t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6},t7={t7},t8={t8}'
+ if t_add_tag is not None:
+ sql_seq = f'{stb_name} {ts} {value} t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6},t7={t7},t8={t8},t9={t8}'
+ if id_change_tag is not None:
+ sql_seq = f'{stb_name} {ts} {value} t0={t0},{id}=\"{tb_name}\",t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6},t7={t7},t8={t8}'
+ if id_double_tag is not None:
+ sql_seq = f'{stb_name} {ts} {value} {id}=\"{tb_name}_1\",t0={t0},t1={t1},{id}=\"{tb_name}_2\",t2={t2},t3={t3},t4={t4},t5={t5},t6={t6},t7={t7},t8={t8}'
+ if t_add_tag is not None:
+ sql_seq = f'{stb_name} {ts} {value} {id}=\"{tb_name}\",t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6},t7={t7},t8={t8},t11={t1},t10={t8}'
+ if t_mul_tag is not None:
+ sql_seq = f'{stb_name} {ts} {value} {id}=\"{tb_name}\",t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6}'
+ if id_noexist_tag is not None:
+ sql_seq = f'{stb_name} {ts} {value} t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6}'
+ if t_multi_tag is not None:
+ sql_seq = f'{stb_name} {ts} {value},{value} {id}=\"{tb_name}\",t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6}'
+ if t_blank_tag is not None:
+ sql_seq = f'{stb_name} {ts} {id}=\"{tb_name}\",t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6},t7={t7},t8={t8}'
+ return sql_seq, stb_name
+
+ def genMulTagColStr(self, genType, count=1):
+ """
+ genType must be tag/col
+ """
+ tag_str = ""
+ col_str = ""
+ if genType == "tag":
+ for i in range(0, count):
+ if i < (count-1):
+ tag_str += f't{i}=f,'
+ else:
+ tag_str += f't{i}=f'
+ return tag_str
+ if genType == "col":
+ col_str = "t"
+ return col_str
+
+ def genLongSql(self, tag_count):
+ stb_name = tdCom.getLongName(7, mode="letters")
+ tb_name = f'{stb_name}_1'
+ tag_str = self.genMulTagColStr("tag", tag_count)
+ col_str = self.genMulTagColStr("col")
+ ts = "1626006833640000000ns"
+ long_sql = stb_name + ' ' + ts + ' ' + col_str + ' ' + f'id=\"{tb_name}\"' + ',' + tag_str
+ return long_sql, stb_name
+
+ def getNoIdTbName(self, stb_name):
+ query_sql = f"select tbname from {stb_name}"
+ tb_name = self.resHandle(query_sql, True)[0][0]
+ return tb_name
+
+ def resHandle(self, query_sql, query_tag):
+ tdSql.execute('reset query cache')
+ row_info = tdSql.query(query_sql, query_tag)
+ print(query_sql)
+ print(row_info)
+ col_info = tdSql.getColNameList(query_sql, query_tag)
+ res_row_list = []
+ sub_list = []
+ for row_mem in row_info:
+ for i in row_mem:
+ sub_list.append(str(i))
+ res_row_list.append(sub_list)
+ res_field_list_without_ts = col_info[0][1:]
+ res_type_list = col_info[1]
+ return res_row_list, res_field_list_without_ts, res_type_list
+
+ def resCmp(self, input_sql, stb_name, query_sql="select * from", condition="", ts=None, id=True, none_check_tag=None):
+ expect_list = self.inputHandle(input_sql)
+ self._conn.insert_telnet_lines([input_sql])
+ query_sql = f"{query_sql} {stb_name} {condition}"
+ res_row_list, res_field_list_without_ts, res_type_list = self.resHandle(query_sql, True)
+ res = tdSql.query(f'select * from {stb_name}', True)
+ print(res)
+
+ res = tdSql.query(f'select * from {stb_name}', True)
+ print(res)
+ time.sleep(2)
+ res = tdSql.query(f'select * from {stb_name}', True)
+ print(res)
+ time.sleep(2)
+ res = tdSql.query(f'select * from {stb_name}', True)
+ print(res)
+ time.sleep(2)
+ res = tdSql.query(f'select * from {stb_name}', True)
+ print(res)
+
+
+ if ts == 0:
+ res_ts = self.dateToTs(res_row_list[0][0])
+ current_time = time.time()
+ if current_time - res_ts < 60:
+ tdSql.checkEqual(res_row_list[0][1:], expect_list[0][1:])
+ else:
+ print("timeout")
+ tdSql.checkEqual(res_row_list[0], expect_list[0])
+ else:
+ if none_check_tag is not None:
+ none_index_list = [i for i,x in enumerate(res_row_list[0]) if x=="None"]
+ none_index_list.reverse()
+ for j in none_index_list:
+ res_row_list[0].pop(j)
+ expect_list[0].pop(j)
+ tdSql.checkEqual(res_row_list[0], expect_list[0])
+ tdSql.checkEqual(res_field_list_without_ts, expect_list[1])
+ for i in range(len(res_type_list)):
+ tdSql.checkEqual(res_type_list[i], expect_list[2][i])
+ # tdSql.checkEqual(res_type_list, expect_list[2])
+
+ def initCheckCase(self):
+ """
+ normal tags and cols, one for every elm
+ """
+ tdCom.cleanTb()
+ input_sql, stb_name = self.genFullTypeSql()
+ self.resCmp(input_sql, stb_name)
+
+ def boolTypeCheckCase(self):
+ """
+ check all normal type
+ """
+ tdCom.cleanTb()
+ full_type_list = ["f", "F", "false", "False", "t", "T", "true", "True"]
+ for t_type in full_type_list:
+ input_sql, stb_name = self.genFullTypeSql(t0=t_type)
+ self.resCmp(input_sql, stb_name)
+
+ def symbolsCheckCase(self):
+ """
+ check symbols = `~!@#$%^&*()_-+={[}]\|:;'\",<.>/?
+ """
+ '''
+ please test :
+ binary_symbols = '\"abcd`~!@#$%^&*()_-{[}]|:;<.>?lfjal"\'\'"\"'
+ '''
+ tdCom.cleanTb()
+ binary_symbols = '"aaa"'
+ # binary_symbols = '"abcd`~!@#$%^&*()_-{[}]|:;<.>?lfjal"'
+ nchar_symbols = f'L{binary_symbols}'
+ input_sql1, stb_name1 = self.genFullTypeSql(value=binary_symbols, t7=binary_symbols, t8=nchar_symbols)
+
+ # input_sql2, stb_name2 = self.genFullTypeSql(value=nchar_symbols, t7=binary_symbols, t8=nchar_symbols)
+ self.resCmp(input_sql1, stb_name1)
+ # self.resCmp(input_sql2, stb_name2)
+
+ def tsCheckCase(self):
+ """
+ test ts list --> ["1626006833639000000ns", "1626006833639019us", "1626006833640ms", "1626006834s", "1626006822639022"]
+ # ! us级时间戳都为0时，数据库中查询显示，但python接口拿到的结果不显示 .000000的情况请确认，目前修改时间处理代码可以通过
+ """
+ tdCom.cleanTb()
+ ts_list = ["1626006833639000000ns", "1626006833639019us", "1626006833640ms", "1626006834s", "1626006822639022", 0]
+ for ts in ts_list:
+ input_sql, stb_name = self.genFullTypeSql(ts=ts)
+ self.resCmp(input_sql, stb_name, ts=ts)
+
+ def idSeqCheckCase(self):
+ """
+ check id.index in tags
+ eg: t0=**,id=**,t1=**
+ """
+ tdCom.cleanTb()
+ input_sql, stb_name = self.genFullTypeSql(id_change_tag=True)
+ self.resCmp(input_sql, stb_name)
+
+ def idUpperCheckCase(self):
+ """
+ check id param
+ eg: id and ID
+ """
+ tdCom.cleanTb()
+ input_sql, stb_name = self.genFullTypeSql(id_upper_tag=True)
+ self.resCmp(input_sql, stb_name)
+ input_sql, stb_name = self.genFullTypeSql(id_change_tag=True, id_upper_tag=True)
+ self.resCmp(input_sql, stb_name)
+
+ def noIdCheckCase(self):
+ """
+ id not exist
+ """
+ tdCom.cleanTb()
+ input_sql, stb_name = self.genFullTypeSql(id_noexist_tag=True)
+ self.resCmp(input_sql, stb_name)
+ query_sql = f"select tbname from {stb_name}"
+ res_row_list = self.resHandle(query_sql, True)[0]
+ if len(res_row_list[0][0]) > 0:
+ tdSql.checkColNameList(res_row_list, res_row_list)
+ else:
+ tdSql.checkColNameList(res_row_list, "please check noIdCheckCase")
+
+ def maxColTagCheckCase(self):
+ """
+ max tag count is 128
+ """
+ for input_sql in [self.genLongSql(128)[0]]:
+ tdCom.cleanTb()
+ self._conn.insert_telnet_lines([input_sql])
+ for input_sql in [self.genLongSql(129)[0]]:
+ tdCom.cleanTb()
+ try:
+ self._conn.insert_telnet_lines([input_sql])
+ except LinesError:
+ pass
+
+ def idIllegalNameCheckCase(self):
+ """
+ test illegal id name
+ mix "`~!@#$¥%^&*()-+={}|[]、「」【】\:;《》<>?"
+ """
+ tdCom.cleanTb()
+ rstr = list("`~!@#$¥%^&*()-+={}|[]、「」【】\:;《》<>?")
+ for i in rstr:
+ input_sql = self.genFullTypeSql(tb_name=f"\"aaa{i}bbb\"")[0]
+ try:
+ self._conn.insert_telnet_lines([input_sql])
+ except LinesError:
+ pass
+
+ def idStartWithNumCheckCase(self):
+ """
+ id is start with num
+ """
+ tdCom.cleanTb()
+ input_sql = self.genFullTypeSql(tb_name=f"\"1aaabbb\"")[0]
+ try:
+ self._conn.insert_telnet_lines([input_sql])
+ except LinesError:
+ pass
+
+ def nowTsCheckCase(self):
+ """
+ check now unsupported
+ """
+ tdCom.cleanTb()
+ input_sql = self.genFullTypeSql(ts="now")[0]
+ try:
+ self._conn.insert_telnet_lines([input_sql])
+ except LinesError:
+ pass
+
+ def dateFormatTsCheckCase(self):
+ """
+ check date format ts unsupported
+ """
+ tdCom.cleanTb()
+ input_sql = self.genFullTypeSql(ts="2021-07-21\ 19:01:46.920")[0]
+ try:
+ self._conn.insert_telnet_lines([input_sql])
+ except LinesError:
+ pass
+
+ def illegalTsCheckCase(self):
+ """
+ check ts format like 16260068336390us19
+ """
+ tdCom.cleanTb()
+ input_sql = self.genFullTypeSql(ts="16260068336390us19")[0]
+ try:
+ self._conn.insert_telnet_lines([input_sql])
+ except LinesError:
+ pass
+
+ def tagValueLengthCheckCase(self):
+ """
+ check full type tag value limit
+ """
+ tdCom.cleanTb()
+ # i8
+ for t1 in ["-127i8", "127i8"]:
+ input_sql, stb_name = self.genFullTypeSql(t1=t1)
+ self.resCmp(input_sql, stb_name)
+ for t1 in ["-128i8", "128i8"]:
+ input_sql = self.genFullTypeSql(t1=t1)[0]
+ try:
+ self._conn.insert_telnet_lines([input_sql])
+ except LinesError:
+ pass
+
+ #i16
+ for t2 in ["-32767i16", "32767i16"]:
+ input_sql, stb_name = self.genFullTypeSql(t2=t2)
+ self.resCmp(input_sql, stb_name)
+ for t2 in ["-32768i16", "32768i16"]:
+ input_sql = self.genFullTypeSql(t2=t2)[0]
+ try:
+ self._conn.insert_telnet_lines([input_sql])
+ except LinesError:
+ pass
+
+ #i32
+ for t3 in ["-2147483647i32", "2147483647i32"]:
+ input_sql, stb_name = self.genFullTypeSql(t3=t3)
+ self.resCmp(input_sql, stb_name)
+ for t3 in ["-2147483648i32", "2147483648i32"]:
+ input_sql = self.genFullTypeSql(t3=t3)[0]
+ try:
+ self._conn.insert_telnet_lines([input_sql])
+ except LinesError:
+ pass
+
+ #i64
+ for t4 in ["-9223372036854775807i64", "9223372036854775807i64"]:
+ input_sql, stb_name = self.genFullTypeSql(t4=t4)
+ self.resCmp(input_sql, stb_name)
+ for t4 in ["-9223372036854775808i64", "9223372036854775808i64"]:
+ input_sql = self.genFullTypeSql(t4=t4)[0]
+ try:
+ self._conn.insert_telnet_lines([input_sql])
+ except LinesError:
+ pass
+
+ # f32
+ for t5 in [f"{-3.4028234663852885981170418348451692544*(10**38)}f32", f"{3.4028234663852885981170418348451692544*(10**38)}f32"]:
+ input_sql, stb_name = self.genFullTypeSql(t5=t5)
+ self.resCmp(input_sql, stb_name)
+ # * limit set to 4028234664*(10**38)
+ for t5 in [f"{-3.4028234664*(10**38)}f32", f"{3.4028234664*(10**38)}f32"]:
+ input_sql = self.genFullTypeSql(t5=t5)[0]
+ try:
+ self._conn.insert_telnet_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
+
+
+ # f64
+ for t6 in [f'{-1.79769*(10**308)}f64', f'{-1.79769*(10**308)}f64']:
+ input_sql, stb_name = self.genFullTypeSql(t6=t6)
+ self.resCmp(input_sql, stb_name)
+ # * limit set to 1.797693134862316*(10**308)
+ for c6 in [f'{-1.797693134862316*(10**308)}f64', f'{-1.797693134862316*(10**308)}f64']:
+ input_sql = self.genFullTypeSql(c6=c6)[0]
+ try:
+ self._conn.insert_telnet_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
+
+ # binary
+ stb_name = tdCom.getLongName(7, "letters")
+ input_sql = f'{stb_name} 1626006833639000000ns t t0=t,t1="{tdCom.getLongName(16374, "letters")}"'
+ self._conn.insert_telnet_lines([input_sql])
+
+ input_sql = f'{stb_name} 1626006833639000000ns t t0=t,t1="{tdCom.getLongName(16375, "letters")}"'
+ try:
+ self._conn.insert_telnet_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ pass
+
+ # nchar
+ # * legal nchar could not be larger than 16374/4
+ stb_name = tdCom.getLongName(7, "letters")
+ input_sql = f'{stb_name} 1626006833639000000ns t t0=t,t1=L"{tdCom.getLongName(4093, "letters")}"'
+ self._conn.insert_telnet_lines([input_sql])
+
+ input_sql = f'{stb_name} 1626006833639000000ns t t0=t,t1=L"{tdCom.getLongName(4094, "letters")}"'
+ try:
+ self._conn.insert_telnet_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
+
+ def colValueLengthCheckCase(self):
+ """
+ check full type col value limit
+ """
+ tdCom.cleanTb()
+ # i8
+ for c1 in ["-127i8", "127i8"]:
+ input_sql, stb_name = self.genFullTypeSql(c1=c1)
+ self.resCmp(input_sql, stb_name)
+
+ for c1 in ["-128i8", "128i8"]:
+ input_sql = self.genFullTypeSql(c1=c1)[0]
+ try:
+ self._conn.insert_telnet_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
+ # i16
+ for c2 in ["-32767i16"]:
+ input_sql, stb_name = self.genFullTypeSql(c2=c2)
+ self.resCmp(input_sql, stb_name)
+ for c2 in ["-32768i16", "32768i16"]:
+ input_sql = self.genFullTypeSql(c2=c2)[0]
+ try:
+ self._conn.insert_telnet_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
+
+ # i32
+ for c3 in ["-2147483647i32"]:
+ input_sql, stb_name = self.genFullTypeSql(c3=c3)
+ self.resCmp(input_sql, stb_name)
+ for c3 in ["-2147483648i32", "2147483648i32"]:
+ input_sql = self.genFullTypeSql(c3=c3)[0]
+ try:
+ self._conn.insert_telnet_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
+
+ # i64
+ for c4 in ["-9223372036854775807i64"]:
+ input_sql, stb_name = self.genFullTypeSql(c4=c4)
+ self.resCmp(input_sql, stb_name)
+ for c4 in ["-9223372036854775808i64", "9223372036854775808i64"]:
+ input_sql = self.genFullTypeSql(c4=c4)[0]
+ try:
+ self._conn.insert_telnet_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
+
+ # f32
+ for c5 in [f"{-3.4028234663852885981170418348451692544*(10**38)}f32", f"{3.4028234663852885981170418348451692544*(10**38)}f32"]:
+ input_sql, stb_name = self.genFullTypeSql(c5=c5)
+ self.resCmp(input_sql, stb_name)
+ # * limit set to 4028234664*(10**38)
+ for c5 in [f"{-3.4028234664*(10**38)}f32", f"{3.4028234664*(10**38)}f32"]:
+ input_sql = self.genFullTypeSql(c5=c5)[0]
+ try:
+ self._conn.insert_telnet_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
+
+ # f64
+ for c6 in [f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64', f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64']:
+ input_sql, stb_name = self.genFullTypeSql(c6=c6)
+ self.resCmp(input_sql, stb_name)
+ # * limit set to 1.797693134862316*(10**308)
+ for c6 in [f'{-1.797693134862316*(10**308)}f64', f'{-1.797693134862316*(10**308)}f64']:
+ input_sql = self.genFullTypeSql(c6=c6)[0]
+ try:
+ self._conn.insert_telnet_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
+
+ # # binary
+ stb_name = tdCom.getLongName(7, "letters")
+ input_sql = f'{stb_name} 1626006833639000000ns "{tdCom.getLongName(16374, "letters")}" t0=t'
+ self._conn.insert_telnet_lines([input_sql])
+
+ input_sql = f'{stb_name} 1626006833639000000ns "{tdCom.getLongName(16375, "letters")}" t0=t'
+ try:
+ self._conn.insert_telnet_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
+
+ # nchar
+ # * legal nchar could not be larger than 16374/4
+ stb_name = tdCom.getLongName(7, "letters")
+ input_sql = f'{stb_name} 1626006833639000000ns L"{tdCom.getLongName(4093, "letters")}" t0=t'
+ self._conn.insert_telnet_lines([input_sql])
+
+ input_sql = f'{stb_name} 1626006833639000000ns L"{tdCom.getLongName(4094, "letters")}" t0=t'
+ try:
+ self._conn.insert_telnet_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
+
+ def tagColIllegalValueCheckCase(self):
+
+ """
+ test illegal tag col value
+ """
+ tdCom.cleanTb()
+ # bool
+ for i in ["TrUe", "tRue", "trUe", "truE", "FalsE", "fAlse", "faLse", "falSe", "falsE"]:
+ input_sql1 = self.genFullTypeSql(t0=i)[0]
+ try:
+ self._conn.insert_telnet_lines([input_sql1])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
+ input_sql2 = self.genFullTypeSql(value=i)[0]
+ try:
+ self._conn.insert_telnet_lines([input_sql2])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
+
+ # i8 i16 i32 i64 f32 f64
+ for input_sql in [
+ self.genFullTypeSql(t1="1s2i8")[0],
+ self.genFullTypeSql(t2="1s2i16")[0],
+ self.genFullTypeSql(t3="1s2i32")[0],
+ self.genFullTypeSql(t4="1s2i64")[0],
+ self.genFullTypeSql(t5="11.1s45f32")[0],
+ self.genFullTypeSql(t6="11.1s45f64")[0],
+ ]:
+ try:
+ self._conn.insert_telnet_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
+
+ # check binary and nchar blank
+ stb_name = tdCom.getLongName(7, "letters")
+
+ input_sql1 = f'{stb_name} 1626006833639000000ns "abc aaa" t0=t'
+ input_sql2 = f'{stb_name} 1626006833639000000ns L"abc aaa" t0=t'
+ input_sql3 = f'{stb_name} 1626006833639000000ns t t0="abc aaa"'
+ input_sql4 = f'{stb_name} 1626006833639000000ns t t0=L"abc aaa"'
+ for input_sql in [input_sql1, input_sql2, input_sql3, input_sql4]:
+ try:
+ self._conn.insert_telnet_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
+
+ # check accepted binary and nchar symbols
+ # # * ~!@#$¥%^&*()-+={}|[]、「」:;
+ for symbol in list('~!@#$¥%^&*()-+={}|[]、「」:;'):
+ input_sql1 = f'{stb_name} 1626006833639000000ns "abc{symbol}aaa" t0=t'
+ input_sql2 = f'{stb_name} 1626006833639000000ns t t0=t,t1="abc{symbol}aaa"'
+ self._conn.insert_telnet_lines([input_sql1])
+ self._conn.insert_telnet_lines([input_sql2])
+
+
+ def duplicateIdTagColInsertCheckCase(self):
+ """
+ check duplicate Id Tag Col
+ """
+ tdCom.cleanTb()
+ input_sql_id = self.genFullTypeSql(id_double_tag=True)[0]
+ try:
+ self._conn.insert_telnet_lines([input_sql_id])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
+
+ input_sql = self.genFullTypeSql()[0]
+ input_sql_tag = input_sql.replace("t5", "t6")
+ try:
+ self._conn.insert_telnet_lines([input_sql_tag])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
+
+ ##### stb exist #####
+ def noIdStbExistCheckCase(self):
+ """
+ case no id when stb exist
+ """
+ tdCom.cleanTb()
+ input_sql, stb_name = self.genFullTypeSql(tb_name="sub_table_0123456", t0="f", value="f")
+ self.resCmp(input_sql, stb_name)
+ input_sql, stb_name = self.genFullTypeSql(stb_name=stb_name, id_noexist_tag=True, t0="f", value="f")
+ self.resCmp(input_sql, stb_name, condition='where tbname like "t_%"')
+ tdSql.query(f"select * from {stb_name}")
+ tdSql.checkRows(2)
+ # TODO cover other case
+
+ def duplicateInsertExistCheckCase(self):
+ """
+ check duplicate insert when stb exist
+ """
+ tdCom.cleanTb()
+ input_sql, stb_name = self.genFullTypeSql()
+ self.resCmp(input_sql, stb_name)
+ self._conn.insert_telnet_lines([input_sql])
+ self.resCmp(input_sql, stb_name)
+
+ def tagColBinaryNcharLengthCheckCase(self):
+ """
+ check length increase
+ """
+ tdCom.cleanTb()
+ input_sql, stb_name = self.genFullTypeSql()
+ self.resCmp(input_sql, stb_name)
+ tb_name = tdCom.getLongName(5, "letters")
+ input_sql, stb_name = self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name,t7="\"binaryTagValuebinaryTagValue\"", t8="L\"ncharTagValuencharTagValue\"", c7="\"binaryTagValuebinaryTagValue\"", c8="L\"ncharTagValuencharTagValue\"")
+ self.resCmp(input_sql, stb_name, condition=f'where tbname like "{tb_name}"')
+
+ def tagColAddDupIDCheckCase(self):
+ """
+ check column and tag count add, stb and tb duplicate
+ * tag: alter table ...
+ * col: when update==0 and ts is same, unchange
+ * so this case tag&&value will be added,
+ * col is added without value when update==0
+ * col is added with value when update==1
+ """
+ tdCom.cleanTb()
+ tb_name = tdCom.getLongName(7, "letters")
+ for db_update_tag in [0, 1]:
+ if db_update_tag == 1 :
+ self.createDb("test_update", db_update_tag=db_update_tag)
+ input_sql, stb_name = self.genFullTypeSql(tb_name=tb_name, t0="f", value="f")
+ self.resCmp(input_sql, stb_name)
+ self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name, t0="f", value="f", ct_add_tag=True)
+ if db_update_tag == 1 :
+ self.resCmp(input_sql, stb_name, condition=f'where tbname like "{tb_name}"')
+ else:
+ self.resCmp(input_sql, stb_name, condition=f'where tbname like "{tb_name}"', none_check_tag=True)
+
+ def tagColAddCheckCase(self):
+ """
+ check column and tag count add
+ """
+ tdCom.cleanTb()
+ tb_name = tdCom.getLongName(7, "letters")
+ input_sql, stb_name = self.genFullTypeSql(tb_name=tb_name, t0="f", value="f")
+ self.resCmp(input_sql, stb_name)
+ tb_name_1 = tdCom.getLongName(7, "letters")
+ input_sql, stb_name = self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name_1, t0="f", value="f", ct_add_tag=True)
+ self.resCmp(input_sql, stb_name, condition=f'where tbname like "{tb_name_1}"')
+ res_row_list = self.resHandle(f"select c10,c11,t10,t11 from {tb_name}", True)[0]
+ tdSql.checkEqual(res_row_list[0], ['None', 'None', 'None', 'None'])
+ self.resCmp(input_sql, stb_name, condition=f'where tbname like "{tb_name}"', none_check_tag=True)
+
+ def tagMd5Check(self):
+ """
+ condition: stb not change
+ insert two table, keep tag unchange, change col
+ """
+ tdCom.cleanTb()
+ input_sql, stb_name = self.genFullTypeSql(t0="f", value="f", id_noexist_tag=True)
+ self.resCmp(input_sql, stb_name)
+ tb_name1 = self.getNoIdTbName(stb_name)
+ input_sql, stb_name = self.genFullTypeSql(stb_name=stb_name, t0="f", value="f", id_noexist_tag=True)
+ self.resCmp(input_sql, stb_name)
+ tb_name2 = self.getNoIdTbName(stb_name)
+ tdSql.query(f"select * from {stb_name}")
+ tdSql.checkRows(1)
+ tdSql.checkEqual(tb_name1, tb_name2)
+ input_sql, stb_name = self.genFullTypeSql(stb_name=stb_name, t0="f", value="f", id_noexist_tag=True, ct_add_tag=True)
+ self._conn.insert_telnet_lines([input_sql])
+ tb_name3 = self.getNoIdTbName(stb_name)
+ tdSql.query(f"select * from {stb_name}")
+ tdSql.checkRows(2)
+ tdSql.checkNotEqual(tb_name1, tb_name3)
+
+ # * tag binary max is 16384, col+ts binary max 49151
+ def tagColBinaryMaxLengthCheckCase(self):
+ """
+ every binary and nchar must be length+2
+ """
+ tdCom.cleanTb()
+ stb_name = tdCom.getLongName(7, "letters")
+ tb_name = f'{stb_name}_1'
+ input_sql = f'{stb_name},id="{tb_name}",t0=t c0=f 1626006833639000000ns'
+ self._conn.insert_telnet_lines([input_sql])
+
+ # * every binary and nchar must be length+2, so here is two tag, max length could not larger than 16384-2*2
+ input_sql = f'{stb_name},t0=t,t1="{tdCom.getLongName(16374, "letters")}",t2="{tdCom.getLongName(5, "letters")}" c0=f 1626006833639000000ns'
+ self._conn.insert_telnet_lines([input_sql])
+
+ tdSql.query(f"select * from {stb_name}")
+ tdSql.checkRows(2)
+ input_sql = f'{stb_name},t0=t,t1="{tdCom.getLongName(16374, "letters")}",t2="{tdCom.getLongName(6, "letters")}" c0=f 1626006833639000000ns'
+ try:
+ self._conn.insert_telnet_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError:
+ pass
+ tdSql.query(f"select * from {stb_name}")
+ tdSql.checkRows(2)
+
+ # # * check col，col+ts max in describe ---> 16143
+ input_sql = f'{stb_name},t0=t c0=f,c1="{tdCom.getLongName(16374, "letters")}",c2="{tdCom.getLongName(16374, "letters")}",c3="{tdCom.getLongName(16374, "letters")}",c4="{tdCom.getLongName(12, "letters")}" 1626006833639000000ns'
+ self._conn.insert_telnet_lines([input_sql])
+
+ tdSql.query(f"select * from {stb_name}")
+ tdSql.checkRows(3)
+ input_sql = f'{stb_name},t0=t c0=f,c1="{tdCom.getLongName(16374, "letters")}",c2="{tdCom.getLongName(16374, "letters")}",c3="{tdCom.getLongName(16374, "letters")}",c4="{tdCom.getLongName(13, "letters")}" 1626006833639000000ns'
+ try:
+ self._conn.insert_telnet_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
+ tdSql.query(f"select * from {stb_name}")
+ tdSql.checkRows(3)
+
+ # * tag nchar max is 16374/4, col+ts nchar max 49151
+ def tagColNcharMaxLengthCheckCase(self):
+ """
+ check nchar length limit
+ """
+ tdCom.cleanTb()
+ stb_name = tdCom.getLongName(7, "letters")
+ tb_name = f'{stb_name}_1'
+ input_sql = f'{stb_name},id="{tb_name}",t0=t c0=f 1626006833639000000ns'
+ code = self._conn.insert_telnet_lines([input_sql])
+
+ # * legal nchar could not be larger than 16374/4
+ input_sql = f'{stb_name},t0=t,t1=L"{tdCom.getLongName(4093, "letters")}",t2=L"{tdCom.getLongName(1, "letters")}" c0=f 1626006833639000000ns'
+ self._conn.insert_telnet_lines([input_sql])
+ tdSql.query(f"select * from {stb_name}")
+ tdSql.checkRows(2)
+ input_sql = f'{stb_name},t0=t,t1=L"{tdCom.getLongName(4093, "letters")}",t2=L"{tdCom.getLongName(2, "letters")}" c0=f 1626006833639000000ns'
+ try:
+ self._conn.insert_telnet_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
+ tdSql.query(f"select * from {stb_name}")
+ tdSql.checkRows(2)
+
+ input_sql = f'{stb_name},t0=t c0=f,c1=L"{tdCom.getLongName(4093, "letters")}",c2=L"{tdCom.getLongName(4093, "letters")}",c3=L"{tdCom.getLongName(4093, "letters")}",c4=L"{tdCom.getLongName(4, "letters")}" 1626006833639000000ns'
+ self._conn.insert_telnet_lines([input_sql])
+ tdSql.query(f"select * from {stb_name}")
+ tdSql.checkRows(3)
+ input_sql = f'{stb_name},t0=t c0=f,c1=L"{tdCom.getLongName(4093, "letters")}",c2=L"{tdCom.getLongName(4093, "letters")}",c3=L"{tdCom.getLongName(4093, "letters")}",c4=L"{tdCom.getLongName(5, "letters")}" 1626006833639000000ns'
+ try:
+ self._conn.insert_telnet_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
+ tdSql.query(f"select * from {stb_name}")
+ tdSql.checkRows(3)
+
+ def batchInsertCheckCase(self):
+ """
+ test batch insert
+ """
+ tdCom.cleanTb()
+ stb_name = tdCom.getLongName(8, "letters")
+ tdSql.execute(f'create stable {stb_name}(ts timestamp, f int) tags(t1 bigint)')
+ lines = ["st123456,t1=3i64,t2=4f64,t3=\"t3\" c1=3i64,c3=L\"passit\",c2=false,c4=4f64 1626006833639000000ns",
+ "st123456,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin\",c2=true,c4=5f64,c5=5f64 1626006833640000000ns",
+ f"{stb_name},t2=5f64,t3=L\"ste\" c1=true,c2=4i64,c3=\"iam\" 1626056811823316532ns",
+ "stf567890,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin\",c2=true,c4=5f64,c5=5f64,c6=7u64 1626006933640000000ns",
+ "st123456,t1=4i64,t2=5f64,t3=\"t4\" c1=3i64,c3=L\"passitagain\",c2=true,c4=5f64 1626006833642000000ns",
+ f"{stb_name},t2=5f64,t3=L\"ste2\" c3=\"iamszhou\",c4=false 1626056811843316532ns",
+ f"{stb_name},t2=5f64,t3=L\"ste2\" c3=\"iamszhou\",c4=false,c5=32i8,c6=64i16,c7=32i32,c8=88.88f32 1626056812843316532ns",
+ "st123456,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin\",c2=true,c4=5f64,c5=5f64,c6=7u64 1626006933640000000ns",
+ "st123456,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin_stf\",c2=false,c5=5f64,c6=7u64 1626006933641000000ns"
+ ]
+ self._conn.insert_telnet_lines(lines)
+
+ def multiInsertCheckCase(self, count):
+ """
+ test multi insert
+ """
+ tdCom.cleanTb()
+ sql_list = []
+ stb_name = tdCom.getLongName(8, "letters")
+ tdSql.execute(f'create stable {stb_name}(ts timestamp, f int) tags(t1 bigint)')
+ for i in range(count):
+ input_sql = self.genFullTypeSql(stb_name=stb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', c7=f'"{tdCom.getLongName(8, "letters")}"', id_noexist_tag=True)[0]
+ sql_list.append(input_sql)
+ self._conn.insert_telnet_lines(sql_list)
+
+ def batchErrorInsertCheckCase(self):
+ """
+ test batch error insert
+ """
+ tdCom.cleanTb()
+ stb_name = tdCom.getLongName(8, "letters")
+ lines = ["st123456,t1=3i64,t2=4f64,t3=\"t3\" c1=3i64,c3=L\"passit\",c2=false,c4=4f64 1626006833639000000ns",
+ f"{stb_name},t2=5f64,t3=L\"ste\" c1=tRue,c2=4i64,c3=\"iam\" 1626056811823316532ns"]
+ try:
+ self._conn.insert_telnet_lines(lines)
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
+
+ def genSqlList(self, count=5, stb_name="", tb_name=""):
+ """
+ stb --> supertable
+ tb --> table
+ ts --> timestamp, same default
+ col --> column, same default
+ tag --> tag, same default
+ d --> different
+ s --> same
+ a --> add
+ m --> minus
+ """
+ d_stb_d_tb_list = list()
+ s_stb_s_tb_list = list()
+ s_stb_s_tb_a_col_a_tag_list = list()
+ s_stb_s_tb_m_col_m_tag_list = list()
+ s_stb_d_tb_list = list()
+ s_stb_d_tb_a_col_m_tag_list = list()
+ s_stb_d_tb_a_tag_m_col_list = list()
+ s_stb_s_tb_d_ts_list = list()
+ s_stb_s_tb_d_ts_a_col_m_tag_list = list()
+ s_stb_s_tb_d_ts_a_tag_m_col_list = list()
+ s_stb_d_tb_d_ts_list = list()
+ s_stb_d_tb_d_ts_a_col_m_tag_list = list()
+ s_stb_d_tb_d_ts_a_tag_m_col_list = list()
+ for i in range(count):
+ d_stb_d_tb_list.append(self.genFullTypeSql(t0="f", c0="f"))
+ s_stb_s_tb_list.append(self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', c7=f'"{tdCom.getLongName(8, "letters")}"'))
+ s_stb_s_tb_a_col_a_tag_list.append(self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', c7=f'"{tdCom.getLongName(8, "letters")}"', ct_add_tag=True))
+ s_stb_s_tb_m_col_m_tag_list.append(self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', c7=f'"{tdCom.getLongName(8, "letters")}"', ct_min_tag=True))
+ s_stb_d_tb_list.append(self.genFullTypeSql(stb_name=stb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', c7=f'"{tdCom.getLongName(8, "letters")}"', id_noexist_tag=True))
+ s_stb_d_tb_a_col_m_tag_list.append(self.genFullTypeSql(stb_name=stb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', c7=f'"{tdCom.getLongName(8, "letters")}"', id_noexist_tag=True, ct_am_tag=True))
+ s_stb_d_tb_a_tag_m_col_list.append(self.genFullTypeSql(stb_name=stb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', c7=f'"{tdCom.getLongName(8, "letters")}"', id_noexist_tag=True, ct_ma_tag=True))
+ s_stb_s_tb_d_ts_list.append(self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', c7=f'"{tdCom.getLongName(8, "letters")}"', ts=0))
+ s_stb_s_tb_d_ts_a_col_m_tag_list.append(self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', c7=f'"{tdCom.getLongName(8, "letters")}"', ts=0, ct_am_tag=True))
+ s_stb_s_tb_d_ts_a_tag_m_col_list.append(self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', c7=f'"{tdCom.getLongName(8, "letters")}"', ts=0, ct_ma_tag=True))
+ s_stb_d_tb_d_ts_list.append(self.genFullTypeSql(stb_name=stb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', c7=f'"{tdCom.getLongName(8, "letters")}"', id_noexist_tag=True, ts=0))
+ s_stb_d_tb_d_ts_a_col_m_tag_list.append(self.genFullTypeSql(stb_name=stb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', c7=f'"{tdCom.getLongName(8, "letters")}"', id_noexist_tag=True, ts=0, ct_am_tag=True))
+ s_stb_d_tb_d_ts_a_tag_m_col_list.append(self.genFullTypeSql(stb_name=stb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', c7=f'"{tdCom.getLongName(8, "letters")}"', id_noexist_tag=True, ts=0, ct_ma_tag=True))
+
+ return d_stb_d_tb_list, s_stb_s_tb_list, s_stb_s_tb_a_col_a_tag_list, s_stb_s_tb_m_col_m_tag_list, \
+ s_stb_d_tb_list, s_stb_d_tb_a_col_m_tag_list, s_stb_d_tb_a_tag_m_col_list, s_stb_s_tb_d_ts_list, \
+ s_stb_s_tb_d_ts_a_col_m_tag_list, s_stb_s_tb_d_ts_a_tag_m_col_list, s_stb_d_tb_d_ts_list, \
+ s_stb_d_tb_d_ts_a_col_m_tag_list, s_stb_d_tb_d_ts_a_tag_m_col_list
+
+
+ def genMultiThreadSeq(self, sql_list):
+ tlist = list()
+ for insert_sql in sql_list:
+ t = threading.Thread(target=self._conn.insert_telnet_lines,args=([insert_sql[0]],))
+ tlist.append(t)
+ return tlist
+
+ def multiThreadRun(self, tlist):
+ for t in tlist:
+ t.start()
+ for t in tlist:
+ t.join()
+
+ def stbInsertMultiThreadCheckCase(self):
+ """
+ thread input different stb
+ """
+ tdCom.cleanTb()
+ input_sql = self.genSqlList()[0]
+ self.multiThreadRun(self.genMultiThreadSeq(input_sql))
+ tdSql.query(f"show tables;")
+ tdSql.checkRows(5)
+
+ def sStbStbDdataInsertMultiThreadCheckCase(self):
+ """
+ thread input same stb tb, different data, result keep first data
+ """
+ tdCom.cleanTb()
+ tb_name = tdCom.getLongName(7, "letters")
+ input_sql, stb_name = self.genFullTypeSql(tb_name=tb_name)
+ self.resCmp(input_sql, stb_name)
+ s_stb_s_tb_list = self.genSqlList(stb_name=stb_name, tb_name=tb_name)[1]
+ self.multiThreadRun(self.genMultiThreadSeq(s_stb_s_tb_list))
+ tdSql.query(f"show tables;")
+ tdSql.checkRows(1)
+ expected_tb_name = self.getNoIdTbName(stb_name)[0]
+ tdSql.checkEqual(tb_name, expected_tb_name)
+ tdSql.query(f"select * from {stb_name};")
+ tdSql.checkRows(1)
+
+ def sStbStbDdataAtcInsertMultiThreadCheckCase(self):
+ """
+ thread input same stb tb, different data, add columes and tags, result keep first data
+ """
+ tdCom.cleanTb()
+ tb_name = tdCom.getLongName(7, "letters")
+ input_sql, stb_name = self.genFullTypeSql(tb_name=tb_name)
+ self.resCmp(input_sql, stb_name)
+ s_stb_s_tb_a_col_a_tag_list = self.genSqlList(stb_name=stb_name, tb_name=tb_name)[2]
+ self.multiThreadRun(self.genMultiThreadSeq(s_stb_s_tb_a_col_a_tag_list))
+ tdSql.query(f"show tables;")
+ tdSql.checkRows(1)
+ expected_tb_name = self.getNoIdTbName(stb_name)[0]
+ tdSql.checkEqual(tb_name, expected_tb_name)
+ tdSql.query(f"select * from {stb_name};")
+ tdSql.checkRows(1)
+
+ def sStbStbDdataMtcInsertMultiThreadCheckCase(self):
+ """
+ thread input same stb tb, different data, minus columes and tags, result keep first data
+ """
+ tdCom.cleanTb()
+ tb_name = tdCom.getLongName(7, "letters")
+ input_sql, stb_name = self.genFullTypeSql(tb_name=tb_name)
+ self.resCmp(input_sql, stb_name)
+ s_stb_s_tb_m_col_m_tag_list = self.genSqlList(stb_name=stb_name, tb_name=tb_name)[3]
+ self.multiThreadRun(self.genMultiThreadSeq(s_stb_s_tb_m_col_m_tag_list))
+ tdSql.query(f"show tables;")
+ tdSql.checkRows(1)
+ expected_tb_name = self.getNoIdTbName(stb_name)[0]
+ tdSql.checkEqual(tb_name, expected_tb_name)
+ tdSql.query(f"select * from {stb_name};")
+ tdSql.checkRows(1)
+
+ def sStbDtbDdataInsertMultiThreadCheckCase(self):
+ """
+ thread input same stb, different tb, different data
+ """
+ tdCom.cleanTb()
+ input_sql, stb_name = self.genFullTypeSql()
+ self.resCmp(input_sql, stb_name)
+ s_stb_d_tb_list = self.genSqlList(stb_name=stb_name)[4]
+ self.multiThreadRun(self.genMultiThreadSeq(s_stb_d_tb_list))
+ tdSql.query(f"show tables;")
+ tdSql.checkRows(6)
+
+ def sStbDtbDdataAcMtInsertMultiThreadCheckCase(self):
+ """
+ #! concurrency conflict
+ """
+ """
+ thread input same stb, different tb, different data, add col, mul tag
+ """
+ tdCom.cleanTb()
+ input_sql, stb_name = self.genFullTypeSql()
+ self.resCmp(input_sql, stb_name)
+ s_stb_d_tb_a_col_m_tag_list = self.genSqlList(stb_name=stb_name)[5]
+ self.multiThreadRun(self.genMultiThreadSeq(s_stb_d_tb_a_col_m_tag_list))
+ tdSql.query(f"show tables;")
+ tdSql.checkRows(6)
+
+ def sStbDtbDdataAtMcInsertMultiThreadCheckCase(self):
+ """
+ #! concurrency conflict
+ """
+ """
+ thread input same stb, different tb, different data, add tag, mul col
+ """
+ tdCom.cleanTb()
+ input_sql, stb_name = self.genFullTypeSql()
+ self.resCmp(input_sql, stb_name)
+ s_stb_d_tb_a_tag_m_col_list = self.genSqlList(stb_name=stb_name)[6]
+ self.multiThreadRun(self.genMultiThreadSeq(s_stb_d_tb_a_tag_m_col_list))
+ tdSql.query(f"show tables;")
+ tdSql.checkRows(6)
+
+ def sStbStbDdataDtsInsertMultiThreadCheckCase(self):
+ """
+ thread input same stb tb, different ts
+ """
+ tdCom.cleanTb()
+ tb_name = tdCom.getLongName(7, "letters")
+ input_sql, stb_name = self.genFullTypeSql(tb_name=tb_name)
+ self.resCmp(input_sql, stb_name)
+ s_stb_s_tb_d_ts_list = self.genSqlList(stb_name=stb_name, tb_name=tb_name)[7]
+ self.multiThreadRun(self.genMultiThreadSeq(s_stb_s_tb_d_ts_list))
+ tdSql.query(f"show tables;")
+ tdSql.checkRows(1)
+ tdSql.query(f"select * from {stb_name}")
+ tdSql.checkRows(6)
+
+ def sStbStbDdataDtsAcMtInsertMultiThreadCheckCase(self):
+ """
+ thread input same stb tb, different ts, add col, mul tag
+ """
+ tdCom.cleanTb()
+ tb_name = tdCom.getLongName(7, "letters")
+ input_sql, stb_name = self.genFullTypeSql(tb_name=tb_name)
+ self.resCmp(input_sql, stb_name)
+ s_stb_s_tb_d_ts_a_col_m_tag_list = self.genSqlList(stb_name=stb_name, tb_name=tb_name)[8]
+ self.multiThreadRun(self.genMultiThreadSeq(s_stb_s_tb_d_ts_a_col_m_tag_list))
+ tdSql.query(f"show tables;")
+ tdSql.checkRows(1)
+ tdSql.query(f"select * from {stb_name}")
+ tdSql.checkRows(6)
+ tdSql.query(f"select * from {stb_name} where t8 is not NULL")
+ tdSql.checkRows(6)
+ tdSql.query(f"select * from {tb_name} where c11 is not NULL;")
+ tdSql.checkRows(5)
+
+ def sStbStbDdataDtsAtMcInsertMultiThreadCheckCase(self):
+ """
+ thread input same stb tb, different ts, add tag, mul col
+ """
+ tdCom.cleanTb()
+ tb_name = tdCom.getLongName(7, "letters")
+ input_sql, stb_name = self.genFullTypeSql(tb_name=tb_name)
+ self.resCmp(input_sql, stb_name)
+ s_stb_s_tb_d_ts_a_tag_m_col_list = self.genSqlList(stb_name=stb_name, tb_name=tb_name)[9]
+ self.multiThreadRun(self.genMultiThreadSeq(s_stb_s_tb_d_ts_a_tag_m_col_list))
+ tdSql.query(f"show tables;")
+ tdSql.checkRows(1)
+ tdSql.query(f"select * from {stb_name}")
+ tdSql.checkRows(6)
+ for c in ["c7", "c8", "c9"]:
+ tdSql.query(f"select * from {stb_name} where {c} is NULL")
+ tdSql.checkRows(5)
+ for t in ["t10", "t11"]:
+ tdSql.query(f"select * from {stb_name} where {t} is not NULL;")
+ tdSql.checkRows(6)
+
+ def sStbDtbDdataDtsInsertMultiThreadCheckCase(self):
+ """
+ thread input same stb, different tb, data, ts
+ """
+ tdCom.cleanTb()
+ input_sql, stb_name = self.genFullTypeSql()
+ self.resCmp(input_sql, stb_name)
+ s_stb_d_tb_d_ts_list = self.genSqlList(stb_name=stb_name)[10]
+ self.multiThreadRun(self.genMultiThreadSeq(s_stb_d_tb_d_ts_list))
+ tdSql.query(f"show tables;")
+ tdSql.checkRows(6)
+
+ def sStbDtbDdataDtsAcMtInsertMultiThreadCheckCase(self):
+ """
+ # ! concurrency conflict
+ """
+ """
+ thread input same stb, different tb, data, ts, add col, mul tag
+ """
+ tdCom.cleanTb()
+ input_sql, stb_name = self.genFullTypeSql()
+ self.resCmp(input_sql, stb_name)
+ s_stb_d_tb_d_ts_a_col_m_tag_list = self.genSqlList(stb_name=stb_name)[11]
+ self.multiThreadRun(self.genMultiThreadSeq(s_stb_d_tb_d_ts_a_col_m_tag_list))
+ tdSql.query(f"show tables;")
+ tdSql.checkRows(6)
+
+
+ def test(self):
+ # input_sql1 = "stb2_5 1626006833610ms 3f64 host=\"host0\",host2=L\"host2\""
+ # input_sql2 = "rfasta,id=\"rfasta_1\",t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64 c0=True,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64 1626006933640000000ns"
+ try:
+ input_sql, stb_name = self.genFullTypeSql()
+ self.resCmp(input_sql, stb_name)
+ except LinesError as err:
+ print(err.errno)
+ # self._conn.insert_telnet_lines([input_sql2])
+ # input_sql3 = f'abcd,id="cc¥Ec",t0=True,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="ndsfdrum",t8=L"ncharTagValue" c0=f,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7="igwoehkm",c8=L"ncharColValue",c9=7u64 0'
+ # print(input_sql3)
+ # input_sql4 = 'hmemeb,id="kilrcrldgf",t0=F,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="fysodjql",t8=L"ncharTagValue" c0=True,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7="waszbfvc",c8=L"ncharColValue",c9=7u64 0'
+ # code = self._conn.insert_telnet_lines([input_sql3])
+ # print(code)
+ # self._conn.insert_telnet_lines([input_sql4])
+
+ def runAll(self):
+ # self.initCheckCase()
+ # self.boolTypeCheckCase()
+ self.symbolsCheckCase()
+
+
+
+
+ # self.tsCheckCase()
+ # self.idSeqCheckCase()
+ # self.idUpperCheckCase()
+ # self.noIdCheckCase()
+ # self.maxColTagCheckCase()
+
+ # self.idIllegalNameCheckCase()
+ # self.idStartWithNumCheckCase()
+ # self.nowTsCheckCase()
+ # self.dateFormatTsCheckCase()
+ # self.illegalTsCheckCase()
+ # self.tagValueLengthCheckCase()
+ # self.colValueLengthCheckCase()
+ # self.tagColIllegalValueCheckCase()
+ # self.duplicateIdTagColInsertCheckCase()
+ # self.noIdStbExistCheckCase()
+ # self.duplicateInsertExistCheckCase()
+ # self.tagColBinaryNcharLengthCheckCase()
+ # self.tagColAddDupIDCheckCase()
+ # self.tagColAddCheckCase()
+ # self.tagMd5Check()
+ # self.tagColBinaryMaxLengthCheckCase()
+ # # self.tagColNcharMaxLengthCheckCase()
+ # self.batchInsertCheckCase()
+ # self.multiInsertCheckCase(1000)
+ # self.batchErrorInsertCheckCase()
+ # # MultiThreads
+ # self.stbInsertMultiThreadCheckCase()
+ # self.sStbStbDdataInsertMultiThreadCheckCase()
+ # self.sStbStbDdataAtcInsertMultiThreadCheckCase()
+ # self.sStbStbDdataMtcInsertMultiThreadCheckCase()
+ # self.sStbDtbDdataInsertMultiThreadCheckCase()
+
+ # # # ! concurrency conflict
+ # # self.sStbDtbDdataAcMtInsertMultiThreadCheckCase()
+ # # self.sStbDtbDdataAtMcInsertMultiThreadCheckCase()
+
+ # self.sStbStbDdataDtsInsertMultiThreadCheckCase()
+
+ # # # ! concurrency conflict
+ # # self.sStbStbDdataDtsAcMtInsertMultiThreadCheckCase()
+ # # self.sStbStbDdataDtsAtMcInsertMultiThreadCheckCase()
+
+ # self.sStbDtbDdataDtsInsertMultiThreadCheckCase()
+
+ # # ! concurrency conflict
+ # # self.sStbDtbDdataDtsAcMtInsertMultiThreadCheckCase()
+
+
+
+ def run(self):
+ print("running {}".format(__file__))
+ self.createDb()
+ try:
+ self.runAll()
+ except Exception as err:
+ print(''.join(traceback.format_exception(None, err, err.__traceback__)))
+ raise err
+ # self.tagColIllegalValueCheckCase()
+ # self.test()
+
+ def stop(self):
+ tdSql.close()
+ tdLog.success("%s successfully executed" % __file__)
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())
diff --git a/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdumpTestNanoSupport.py b/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdumpTestNanoSupport.py
index ca8832170b7706621f5ef9d3225fe2cf16141c34..a2059ec924ad1e2239c2709bc99dd58fbafa1337 100644
--- a/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdumpTestNanoSupport.py
+++ b/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdumpTestNanoSupport.py
@@ -44,7 +44,7 @@ class TDTestCase:
projPath = selfPath[:selfPath.find("tests")]
for root, dirs, files in os.walk(projPath):
- if ("taosdump" in files):
+ if ("taosd" in files):
rootRealPath = os.path.dirname(os.path.realpath(root))
if ("packaging" not in rootRealPath):
buildPath = root[:len(root) - len("/build/bin")]
diff --git a/tests/pytest/tools/taosdemoAllTest/insertInterlaceRowsLarge1M.json b/tests/pytest/tools/taosdemoAllTest/insertInterlaceRowsLarge1M.json
index 1b56830189623d344168918f239887c3359b2645..197f8a208e85ca4ce57c06518a433ec3a3acbac3 100644
--- a/tests/pytest/tools/taosdemoAllTest/insertInterlaceRowsLarge1M.json
+++ b/tests/pytest/tools/taosdemoAllTest/insertInterlaceRowsLarge1M.json
@@ -41,7 +41,7 @@
"batch_create_tbl_num": 10,
"data_source": "rand",
"insert_mode": "taosc",
- "insert_rows": 1000,
+ "insert_rows": 1001,
"childtable_limit": 0,
"childtable_offset":0,
"multi_thread_write_one_tbl": "no",
diff --git a/tests/pytest/tools/taosdemoPerformance.py b/tests/pytest/tools/taosdemoPerformance.py
index 51b064a08e5cd55401f9cf803a8683653f722679..82c57a656dfea12f80fe4eb2b530742c5bfb0916 100644
--- a/tests/pytest/tools/taosdemoPerformance.py
+++ b/tests/pytest/tools/taosdemoPerformance.py
@@ -120,7 +120,7 @@ class taosdemoPerformace:
projPath = selfPath[:selfPath.find("tests")]
for root, dirs, files in os.walk(projPath):
- if ("taosdemo" in files):
+ if ("taosd" in files):
rootRealPath = os.path.dirname(os.path.realpath(root))
if ("packaging" not in rootRealPath):
buildPath = root[:len(root) - len("/build/bin")]
diff --git a/tests/pytest/tools/taosdemoTest.py b/tests/pytest/tools/taosdemoTest.py
index 5662881031a01d19398cce223892eebbd8133c97..3cdcdcef5afcb14c04204d2489571bdfed937080 100644
--- a/tests/pytest/tools/taosdemoTest.py
+++ b/tests/pytest/tools/taosdemoTest.py
@@ -36,7 +36,7 @@ class TDTestCase:
projPath = selfPath[:selfPath.find("tests")]
for root, dirs, files in os.walk(projPath):
- if ("taosdemo" in files):
+ if ("taosd" in files):
rootRealPath = os.path.dirname(os.path.realpath(root))
if ("packaging" not in rootRealPath):
buildPath = root[:len(root) - len("/build/bin")]
diff --git a/tests/pytest/tools/taosdemoTestTblAlt.py b/tests/pytest/tools/taosdemoTestTblAlt.py
index b70525ae4d87465a59ad524067d8b1e4a61d526a..70df535f59cbb97469b7a73e4e230d9a8671bfc7 100644
--- a/tests/pytest/tools/taosdemoTestTblAlt.py
+++ b/tests/pytest/tools/taosdemoTestTblAlt.py
@@ -26,7 +26,7 @@ class TDTestCase:
tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor(), logSql)
- self.numberOfTables = 10
+ self.numberOfTables = 8
self.numberOfRecords = 1000000
def getBuildPath(self):
@@ -86,7 +86,7 @@ class TDTestCase:
while True:
print("query started")
try:
- tdSql.query("select * from test.t9")
+ tdSql.query("select * from test.t7")
except Exception as e:
tdLog.info("select * test failed")
time.sleep(2)
@@ -100,8 +100,8 @@ class TDTestCase:
print("alter table test.meters add column c10 int")
tdSql.execute("alter table test.meters add column c10 int")
- print("insert into test.t9 values (now, 1, 2, 3, 4, 0)")
- tdSql.execute("insert into test.t9 values (now, 1, 2, 3, 4, 0)")
+ print("insert into test.t7 values (now, 1, 2, 3, 4, 0)")
+ tdSql.execute("insert into test.t7 values (now, 1, 2, 3, 4, 0)")
def run(self):
tdSql.prepare()
diff --git a/tests/pytest/tools/taosdumpTest2.py b/tests/pytest/tools/taosdumpTest2.py
index bed0564139e20fb6c562a7258af0cbd5b542069b..839988375b652b0cfad09d8a6de7697de19609ea 100644
--- a/tests/pytest/tools/taosdumpTest2.py
+++ b/tests/pytest/tools/taosdumpTest2.py
@@ -37,7 +37,7 @@ class TDTestCase:
projPath = selfPath[:selfPath.find("tests")]
for root, dirs, files in os.walk(projPath):
- if ("taosdump" in files):
+ if ("taosd" in files):
rootRealPath = os.path.dirname(os.path.realpath(root))
if ("packaging" not in rootRealPath):
buildPath = root[:len(root) - len("/build/bin")]