diff --git a/README-CN.md b/README-CN.md
index afb242d621..d5586c78b7 100644
--- a/README-CN.md
+++ b/README-CN.md
@@ -23,7 +23,7 @@ TDengine是涛思数据专为物联网、车联网、工业互联网、IT运维
TDengine是一个高效的存储、查询、分析时序大数据的平台，专为物联网、车联网、工业互联网、运维监测等优化而设计。您可以像使用关系型数据库MySQL一样来使用它，但建议您在使用前仔细阅读一遍下面的文档，特别是 [数据模型](https://www.taosdata.com/cn/documentation/architecture) 与 [数据建模](https://www.taosdata.com/cn/documentation/model)。除本文档之外，欢迎 [下载产品白皮书](https://www.taosdata.com/downloads/TDengine%20White%20Paper.pdf)。
-# 生成
+# 构建
TDengine目前2.0版服务器仅能在Linux系统上安装和运行，后续会支持Windows、macOS等系统。客户端可以在Windows或Linux上安装和运行。任何OS的应用也可以选择RESTful接口连接服务器taosd。CPU支持X64/ARM64/MIPS64/Alpha64，后续会支持ARM32、RISC-V等CPU架构。用户可根据需求选择通过[源码](https://www.taosdata.com/cn/getting-started/#通过源码安装)或者[安装包](https://www.taosdata.com/cn/getting-started/#通过安装包安装)来安装。本快速指南仅适用于通过源码安装。
@@ -107,7 +107,7 @@ Go 连接器和 Grafana 插件在其他独立仓库，如果安装它们的话
git submodule update --init --recursive
```
-## 生成 TDengine
+## 构建 TDengine
### Linux 系统
@@ -116,6 +116,12 @@ mkdir debug && cd debug
cmake .. && cmake --build .
```
+您可以选择使用 Jemalloc 作为内存分配器，替代默认的 glibc：
+```bash
+apt install autoconf
+cmake .. -DJEMALLOC_ENABLED=true
+```
+
在X86-64、X86、arm64、arm32 和 mips64 平台上，TDengine 生成脚本可以自动检测机器架构。也可以手动配置 CPUTYPE 参数来指定 CPU 类型，如 aarch64 或 aarch32 等。
aarch64：
diff --git a/README.md b/README.md
index 0e1adcd97c..89e35f6e63 100644
--- a/README.md
+++ b/README.md
@@ -110,6 +110,12 @@ mkdir debug && cd debug
cmake .. && cmake --build .
```
+You can use Jemalloc as memory allocator instead of glibc:
+```
+apt install autoconf
+cmake .. -DJEMALLOC_ENABLED=true
+```
+
TDengine build script can detect the host machine's architecture on X86-64, X86, arm64, arm32 and mips64 platform.
You can also specify CPUTYPE option like aarch64 or aarch32 too if the detection result is not correct:
diff --git a/cmake/env.inc b/cmake/env.inc
index 356bd61442..fa15ec6aee 100755
--- a/cmake/env.inc
+++ b/cmake/env.inc
@@ -39,7 +39,7 @@ SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${COMMON_C_FLAGS} ${DEBUG_FLAGS}
SET(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${COMMON_C_FLAGS} ${RELEASE_FLAGS}")
# Set c++ compiler options
-SET(COMMON_CXX_FLAGS "${COMMON_FLAGS} -std=c++11")
+SET(COMMON_CXX_FLAGS "${COMMON_FLAGS} -std=c++11 -Wno-unused-function")
SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${COMMON_CXX_FLAGS} ${DEBUG_FLAGS}")
SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${COMMON_CXX_FLAGS} ${RELEASE_FLAGS}")
diff --git a/documentation20/cn/00.index/docs.md b/documentation20/cn/00.index/docs.md
index 4c37ce598c..ed7156be17 100644
--- a/documentation20/cn/00.index/docs.md
+++ b/documentation20/cn/00.index/docs.md
@@ -42,7 +42,7 @@ TDengine是一个高效的存储、查询、分析时序大数据的平台，专
* [数据写入](/taos-sql#insert)：支持单表单条、多条、多表多条写入，支持历史数据写入
* [数据查询](/taos-sql#select)：支持时间段、值过滤、排序、查询结果手动分页等
* [SQL函数](/taos-sql#functions)：支持各种聚合函数、选择函数、计算函数，如avg, min, diff等
-* [时间维度聚合](/taos-sql#aggregation)：将表中数据按照时间段进行切割后聚合，降维处理
+* [窗口切分聚合](/taos-sql#aggregation)：将表中数据按照时间段等方式进行切割后聚合，降维处理
* [边界限制](/taos-sql#limitation)：库、表、SQL等边界限制条件
* [错误码](/taos-sql/error-code)：TDengine 2.0 错误码以及对应的十进制码
@@ -63,7 +63,7 @@ TDengine是一个高效的存储、查询、分析时序大数据的平台，专
## [高级功能](/advanced-features)
* [连续查询(Continuous Query)](/advanced-features#continuous-query)：基于滑动窗口，定时自动的对数据流进行查询计算
-* [数据订阅(Publisher/Subscriber)](/advanced-features#subscribe)：象典型的消息队列，应用可订阅接收到的最新数据
+* [数据订阅(Publisher/Subscriber)](/advanced-features#subscribe)：类似典型的消息队列，应用可订阅接收到的最新数据
* [缓存(Cache)](/advanced-features#cache)：每个设备最新的数据都会缓存在内存中，可快速获取
* [报警监测](/advanced-features#alert)：根据配置规则，自动监测超限行为数据，并主动推送
diff --git a/documentation20/cn/08.connector/01.java/docs.md b/documentation20/cn/08.connector/01.java/docs.md
index fb47d79268..546e2dbcd3 100644
--- a/documentation20/cn/08.connector/01.java/docs.md
+++ b/documentation20/cn/08.connector/01.java/docs.md
@@ -532,8 +532,9 @@ Query OK, 1 row(s) in set (0.000141s)
| taos-jdbcdriver 版本 | TDengine 版本 | JDK 版本 |
| -------------------- | ----------------- | -------- |
-| 2.0.22 | 2.0.18.0 及以上 | 1.8.x |
-| 2.0.12 - 2.0.21 | 2.0.8.0 - 2.0.17.0 | 1.8.x |
+| 2.0.31 | 2.1.3.0 及以上 | 1.8.x |
+| 2.0.22 - 20.0.30 | 2.0.18.0 - 2.1.2.x | 1.8.x |
+| 2.0.12 - 2.0.21 | 2.0.8.0 - 2.0.17.x | 1.8.x |
| 2.0.4 - 2.0.11 | 2.0.0.0 - 2.0.7.x | 1.8.x |
| 1.0.3 | 1.6.1.x 及以上 | 1.8.x |
| 1.0.2 | 1.6.1.x 及以上 | 1.8.x |
diff --git a/documentation20/cn/08.connector/docs.md b/documentation20/cn/08.connector/docs.md
index 2d76c866d1..aa5fa50b66 100644
--- a/documentation20/cn/08.connector/docs.md
+++ b/documentation20/cn/08.connector/docs.md
@@ -427,12 +427,15 @@ TDengine提供时间驱动的实时流式计算API。可以每隔一指定的时
* res：查询结果集，注意结果集中可能没有记录
* param：调用 `taos_subscribe`时客户程序提供的附加参数
* code：错误码
+
**注意**：在这个回调函数里不可以做耗时过长的处理，尤其是对于返回的结果集中数据较多的情况，否则有可能导致客户端阻塞等异常状态。如果必须进行复杂计算，则建议在另外的线程中进行处理。
* `TAOS_RES *taos_consume(TAOS_SUB *tsub)`
同步模式下，该函数用来获取订阅的结果。 用户应用程序将其置于一个循环之中。 如两次调用`taos_consume`的间隔小于订阅的轮询周期，API将会阻塞，直到时间间隔超过此周期。 如果数据库有新记录到达，该API将返回该最新的记录，否则返回一个没有记录的空结果集。 如果返回值为 `NULL`，说明系统出错。 异步模式下，用户程序不应调用此API。
+ **注意**：在调用 `taos_consume()` 之后，用户应用应确保尽快调用 `taos_fetch_row()` 或 `taos_fetch_block()` 来处理订阅结果，否则服务端会持续缓存查询结果数据等待客户端读取，极端情况下会导致服务端内存消耗殆尽，影响服务稳定性。
+
* `void taos_unsubscribe(TAOS_SUB *tsub, int keepProgress)`
取消订阅。 如参数 `keepProgress` 不为0，API会保留订阅的进度信息，后续调用 `taos_subscribe` 时可以基于此进度继续；否则将删除进度信息，后续只能重新开始读取数据。
diff --git a/documentation20/cn/12.taos-sql/docs.md b/documentation20/cn/12.taos-sql/docs.md
index 278757b81b..844865f6db 100644
--- a/documentation20/cn/12.taos-sql/docs.md
+++ b/documentation20/cn/12.taos-sql/docs.md
@@ -476,9 +476,10 @@ Query OK, 1 row(s) in set (0.001091s)
SELECT select_expr [, select_expr ...]
FROM {tb_name_list}
[WHERE where_condition]
- [INTERVAL (interval_val [, interval_offset])]
- [SLIDING sliding_val]
- [FILL fill_val]
+ [SESSION(ts_col, tol_val)]
+ [STATE_WINDOW(col)]
+ [INTERVAL(interval_val [, interval_offset]) [SLIDING sliding_val]]
+ [FILL(fill_mod_and_val)]
[GROUP BY col_list]
[ORDER BY col_list { DESC | ASC }]
[SLIMIT limit_val [SOFFSET offset_val]]
@@ -853,7 +854,23 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
- 适用于：**表**。
+ 适用于：**表、（超级表）**。
+
+ 说明：从 2.1.3.0 版本开始，TWA 函数可以在由 GROUP BY 划分出单独时间线的情况下用于超级表（也即 GROUP BY tbname）。
+
+- **IRATE**
+ ```mysql
+ SELECT IRATE(field_name) FROM tb_name WHERE clause;
+ ```
+ 功能说明：计算瞬时增长率。使用时间区间中最后两个样本数据来计算瞬时增长速率；如果这两个值呈递减关系，那么只取最后一个数用于计算，而不是使用二者差值。
+
+ 返回结果数据类型：双精度浮点数Double。
+
+ 应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
+
+ 适用于：**表、（超级表）**。
+
+ 说明：（从 2.1.3.0 版本开始新增此函数）IRATE 可以在由 GROUP BY 划分出单独时间线的情况下用于超级表（也即 GROUP BY tbname）。
- **SUM**
```mysql
@@ -1202,13 +1219,14 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
```
### 计算函数
+
- **DIFF**
```mysql
SELECT DIFF(field_name) FROM tb_name [WHERE clause];
```
功能说明：统计表中某列的值与前一行对应值的差。
- 返回结果数据类型： 同应用字段。
+ 返回结果数据类型：同应用字段。
应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
@@ -1226,13 +1244,27 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
Query OK, 2 row(s) in set (0.001162s)
```
+- **DERIVATIVE**
+ ```mysql
+ SELECT DERIVATIVE(field_name, time_interval, ignore_negative) FROM tb_name [WHERE clause];
+ ```
+ 功能说明：统计表中某列数值的单位变化率。其中单位时间区间的长度可以通过 time_interval 参数指定，最小可以是 1 秒（1s）；ignore_negative 参数的值可以是 0 或 1，为 1 时表示忽略负值。
+
+ 返回结果数据类型：双精度浮点数。
+
+ 应用字段：不能应用在 timestamp、binary、nchar、bool 类型字段。
+
+ 适用于：**表、（超级表）**。
+
+ 说明：（从 2.1.3.0 版本开始新增此函数）输出结果行数是范围内总行数减一，第一行没有结果输出。DERIVATIVE 函数可以在由 GROUP BY 划分出单独时间线的情况下用于超级表（也即 GROUP BY tbname）。
+
- **SPREAD**
```mysql
SELECT SPREAD(field_name) FROM { tb_name | stb_name } [WHERE clause];
```
功能说明：统计表/超级表中某列的最大值和最小值之差。
- 返回结果数据类型： 双精度浮点数。
+ 返回结果数据类型：双精度浮点数。
应用字段：不能应用在binary、nchar、bool类型字段。
@@ -1284,39 +1316,45 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
Query OK, 3 row(s) in set (0.001046s)
```
-## 时间维度聚合
+## 按窗口切分聚合
-TDengine支持按时间段进行聚合，可以将表中数据按照时间段进行切割后聚合生成结果，比如温度传感器每秒采集一次数据，但需查询每隔10分钟的温度平均值。这个聚合适合于降维(down sample)操作, 语法如下：
+TDengine 支持按时间段等窗口切分方式进行聚合结果查询，比如温度传感器每秒采集一次数据，但需查询每隔 10 分钟的温度平均值。这类聚合适合于降维（down sample）操作，语法如下：
```mysql
SELECT function_list FROM tb_name
[WHERE where_condition]
- INTERVAL (interval [, offset])
- [SLIDING sliding]
- [FILL ({NONE | VALUE | PREV | NULL | LINEAR | NEXT})]
+ [SESSION(ts_col, tol_val)]
+ [STATE_WINDOW(col)]
+ [INTERVAL(interval [, offset]) [SLIDING sliding]]
+ [FILL({NONE | VALUE | PREV | NULL | LINEAR | NEXT})]
SELECT function_list FROM stb_name
[WHERE where_condition]
- INTERVAL (interval [, offset])
- [SLIDING sliding]
- [FILL ({ VALUE | PREV | NULL | LINEAR | NEXT})]
+ [SESSION(ts_col, tol_val)]
+ [STATE_WINDOW(col)]
+ [INTERVAL(interval [, offset]) [SLIDING sliding]]
+ [FILL({NONE | VALUE | PREV | NULL | LINEAR | NEXT})]
[GROUP BY tags]
```
-- 聚合时间段的长度由关键词INTERVAL指定，最短时间间隔10毫秒（10a），并且支持偏移（偏移必须小于间隔）。聚合查询中，能够同时执行的聚合和选择函数仅限于单个输出的函数：count、avg、sum 、stddev、leastsquares、percentile、min、max、first、last，不能使用具有多行输出结果的函数（例如：top、bottom、diff以及四则运算）。
-- WHERE语句可以指定查询的起止时间和其他过滤条件。
-- SLIDING语句用于指定聚合时间段的前向增量。
-- FILL语句指定某一时间区间数据缺失的情况下的填充模式。填充模式包括以下几种：
- 1. 不进行填充：NONE(默认填充模式)。
- 2. VALUE填充：固定值填充，此时需要指定填充的数值。例如：FILL(VALUE, 1.23)。
- 3. NULL填充：使用NULL填充数据。例如：FILL(NULL)。
- 4. PREV填充：使用前一个非NULL值填充数据。例如：FILL(PREV)。
- 5. NEXT填充：使用下一个非NULL值填充数据。例如：FILL(NEXT)。
+- 在聚合查询中，function_list 位置允许使用聚合和选择函数，并要求每个函数仅输出单个结果（例如：COUNT、AVG、SUM、STDDEV、LEASTSQUARES、PERCENTILE、MIN、MAX、FIRST、LAST），而不能使用具有多行输出结果的函数（例如：TOP、BOTTOM、DIFF 以及四则运算）。
+- 查询过滤、聚合等操作按照每个切分窗口为独立的单位执行。聚合查询目前支持三种窗口的划分方式：
+ 1. 时间窗口：聚合时间段的窗口宽度由关键词 INTERVAL 指定，最短时间间隔 10 毫秒（10a）；并且支持偏移 offset（偏移必须小于间隔），也即时间窗口划分与“UTC 时刻 0”相比的偏移量。SLIDING 语句用于指定聚合时间段的前向增量，也即每次窗口向前滑动的时长。当 SLIDING 与 INTERVAL 取值相等的时候，滑动窗口即为翻转窗口。
+ 2. 状态窗口：使用整数（布尔值）或字符串来标识产生记录时设备的状态量，产生的记录如果具有相同的状态量取值则归属于同一个状态窗口，数值改变后该窗口关闭。状态量所对应的列作为 STAT_WINDOW 语句的参数来指定。
+ 3. 会话窗口：时间戳所在的列由 SESSION 语句的 ts_col 参数指定，会话窗口根据相邻两条记录的时间戳差值来确定是否属于同一个会话——如果时间戳差异在 tol_val 以内，则认为记录仍属于同一个窗口；如果时间变化超过 tol_val，则自动开启下一个窗口。
+- WHERE 语句可以指定查询的起止时间和其他过滤条件。
+- FILL 语句指定某一窗口区间数据缺失的情况下的填充模式。填充模式包括以下几种：
+ 1. 不进行填充：NONE（默认填充模式）。
+ 2. VALUE 填充：固定值填充，此时需要指定填充的数值。例如：FILL(VALUE, 1.23)。
+ 3. PREV 填充：使用前一个非 NULL 值填充数据。例如：FILL(PREV)。
+ 4. NULL 填充：使用 NULL 填充数据。例如：FILL(NULL)。
+ 5. LINEAR 填充：根据前后距离最近的非 NULL 值做线性插值填充。例如：FILL(LINEAR)。
+ 6. NEXT 填充：使用下一个非 NULL 值填充数据。例如：FILL(NEXT)。
说明：
- 1. 使用FILL语句的时候可能生成大量的填充输出，务必指定查询的时间区间。针对每次查询，系统可返回不超过1千万条具有插值的结果。
+ 1. 使用 FILL 语句的时候可能生成大量的填充输出，务必指定查询的时间区间。针对每次查询，系统可返回不超过 1 千万条具有插值的结果。
2. 在时间维度聚合中，返回的结果中时间序列严格单调递增。
- 3. 如果查询对象是超级表，则聚合函数会作用于该超级表下满足值过滤条件的所有表的数据。如果查询中没有使用GROUP BY语句，则返回的结果按照时间序列严格单调递增；如果查询中使用了GROUP BY语句分组，则返回结果中每个GROUP内不按照时间序列严格单调递增。
+ 3. 如果查询对象是超级表，则聚合函数会作用于该超级表下满足值过滤条件的所有表的数据。如果查询中没有使用 GROUP BY 语句，则返回的结果按照时间序列严格单调递增；如果查询中使用了 GROUP BY 语句分组，则返回结果中每个 GROUP 内不按照时间序列严格单调递增。
时间聚合也常被用于连续查询场景，可以参考文档 [连续查询(Continuous Query)](https://www.taosdata.com/cn/documentation/advanced-features#continuous-query)。
@@ -1326,7 +1364,7 @@ SELECT function_list FROM stb_name
CREATE TABLE meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS (location BINARY(64), groupId INT);
```
-针对智能电表采集的数据，以10分钟为一个阶段，计算过去24小时的电流数据的平均值、最大值、电流的中位数、以及随着时间变化的电流走势拟合直线。如果没有计算值，用前一个非NULL值填充。使用的查询语句如下：
+针对智能电表采集的数据，以 10 分钟为一个阶段，计算过去 24 小时的电流数据的平均值、最大值、电流的中位数、以及随着时间变化的电流走势拟合直线。如果没有计算值，用前一个非 NULL 值填充。使用的查询语句如下：
```mysql
SELECT AVG(current), MAX(current), LEASTSQUARES(current, start_val, step_val), PERCENTILE(current, 50) FROM meters
diff --git a/src/client/inc/tscUtil.h b/src/client/inc/tscUtil.h
index 35f3b42811..950d81fb61 100644
--- a/src/client/inc/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@@ -210,7 +210,8 @@ int32_t createProjectionExpr(SQueryInfo* pQueryInfo, STableMetaInfo* pTableMetaI
void clearAllTableMetaInfo(SQueryInfo* pQueryInfo, bool removeMeta);
SColumn* tscColumnClone(const SColumn* src);
-bool tscColumnExists(SArray* pColumnList, int32_t columnIndex, uint64_t uid);
+void tscColumnCopy(SColumn* pDest, const SColumn* pSrc);
+int32_t tscColumnExists(SArray* pColumnList, int32_t columnId, uint64_t uid);
SColumn* tscColumnListInsert(SArray* pColumnList, int32_t columnIndex, uint64_t uid, SSchema* pSchema);
void tscColumnListDestroy(SArray* pColList);
void tscColumnListCopy(SArray* dst, const SArray* src, uint64_t tableUid);
diff --git a/src/client/src/tscGlobalmerge.c b/src/client/src/tscGlobalmerge.c
index d835b37c24..ffec03b65a 100644
--- a/src/client/src/tscGlobalmerge.c
+++ b/src/client/src/tscGlobalmerge.c
@@ -898,7 +898,9 @@ SSDataBlock* doGlobalAggregate(void* param, bool* newgroup) {
SSDataBlock* pBlock = NULL;
while(1) {
bool prev = *newgroup;
+ publishOperatorProfEvent(upstream, QUERY_PROF_BEFORE_OPERATOR_EXEC);
pBlock = upstream->exec(upstream, newgroup);
+ publishOperatorProfEvent(upstream, QUERY_PROF_AFTER_OPERATOR_EXEC);
if (pBlock == NULL) {
*newgroup = prev;
break;
@@ -966,7 +968,9 @@ static SSDataBlock* skipGroupBlock(SOperatorInfo* pOperator, bool* newgroup) {
SSDataBlock* pBlock = NULL;
if (pInfo->currentGroupOffset == 0) {
+ publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_BEFORE_OPERATOR_EXEC);
pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
+ publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_AFTER_OPERATOR_EXEC);
if (pBlock == NULL) {
setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
pOperator->status = OP_EXEC_DONE;
@@ -974,7 +978,9 @@ static SSDataBlock* skipGroupBlock(SOperatorInfo* pOperator, bool* newgroup) {
if (*newgroup == false && pInfo->limit.limit > 0 && pInfo->rowsTotal >= pInfo->limit.limit) {
while ((*newgroup) == false) { // ignore the remain blocks
+ publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_BEFORE_OPERATOR_EXEC);
pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
+ publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_AFTER_OPERATOR_EXEC);
if (pBlock == NULL) {
setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
pOperator->status = OP_EXEC_DONE;
@@ -986,7 +992,10 @@ static SSDataBlock* skipGroupBlock(SOperatorInfo* pOperator, bool* newgroup) {
return pBlock;
}
+ publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_BEFORE_OPERATOR_EXEC);
pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
+ publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_AFTER_OPERATOR_EXEC);
+
if (pBlock == NULL) {
setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
pOperator->status = OP_EXEC_DONE;
@@ -1000,7 +1009,10 @@ static SSDataBlock* skipGroupBlock(SOperatorInfo* pOperator, bool* newgroup) {
}
while ((*newgroup) == false) {
+ publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_BEFORE_OPERATOR_EXEC);
pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
+ publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_AFTER_OPERATOR_EXEC);
+
if (pBlock == NULL) {
setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
pOperator->status = OP_EXEC_DONE;
diff --git a/src/client/src/tscLocal.c b/src/client/src/tscLocal.c
index 2c9717306f..668a9e9406 100644
--- a/src/client/src/tscLocal.c
+++ b/src/client/src/tscLocal.c
@@ -485,6 +485,7 @@ static int32_t tscGetDBInfo(SCreateBuilder *builder, char *result) {
char buf[TSDB_DB_NAME_LEN + 64] = {0};
do {
+ memset(buf, 0, sizeof(buf));
int32_t* lengths = taos_fetch_lengths(pSql);
int32_t ret = tscGetNthFieldResult(row, fields, lengths, 0, buf);
if (0 == ret && STR_NOCASE_EQUAL(buf, strlen(buf), builder->buf, strlen(builder->buf))) {
diff --git a/src/client/src/tscParseInsert.c b/src/client/src/tscParseInsert.c
index a158162dc5..137a7be7c7 100644
--- a/src/client/src/tscParseInsert.c
+++ b/src/client/src/tscParseInsert.c
@@ -1580,7 +1580,6 @@ void tscImportDataFromFile(SSqlObj *pSql) {
SImportFileSupport *pSupporter = calloc(1, sizeof(SImportFileSupport));
SSqlObj *pNew = createSubqueryObj(pSql, 0, parseFileSendDataBlock, pSupporter, TSDB_SQL_INSERT, NULL);
- pCmd->count = 1;
FILE *fp = fopen(pCmd->payload, "rb");
if (fp == NULL) {
diff --git a/src/client/src/tscPrepare.c b/src/client/src/tscPrepare.c
index bac8920d8f..8bb776ffee 100644
--- a/src/client/src/tscPrepare.c
+++ b/src/client/src/tscPrepare.c
@@ -1156,27 +1156,6 @@ static void insertBatchClean(STscStmt* pStmt) {
tfree(pCmd->insertParam.pTableNameList);
-/*
- STableDataBlocks** p = taosHashIterate(pCmd->insertParam.pTableBlockHashList, NULL);
-
- STableDataBlocks* pOneTableBlock = *p;
-
- while (1) {
- SSubmitBlk* pBlocks = (SSubmitBlk*) pOneTableBlock->pData;
-
- pOneTableBlock->size = sizeof(SSubmitBlk);
-
- pBlocks->numOfRows = 0;
-
- p = taosHashIterate(pCmd->insertParam.pTableBlockHashList, p);
- if (p == NULL) {
- break;
- }
-
- pOneTableBlock = *p;
- }
-*/
-
pCmd->insertParam.pDataBlocks = tscDestroyBlockArrayList(pCmd->insertParam.pDataBlocks);
pCmd->insertParam.numOfTables = 0;
@@ -1499,7 +1478,7 @@ int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) {
pRes->numOfRows = 1;
strtolower(pSql->sqlstr, sql);
- tscDebugL("%p SQL: %s", pSql, pSql->sqlstr);
+ tscDebugL("0x%"PRIx64" SQL: %s", pSql->self, pSql->sqlstr);
if (tscIsInsertData(pSql->sqlstr)) {
pStmt->isInsert = true;
@@ -1604,7 +1583,7 @@ int taos_stmt_set_tbname_tags(TAOS_STMT* stmt, const char* name, TAOS_BIND* tags
if (taosHashGetSize(pCmd->insertParam.pTableBlockHashList) > 0) {
SHashObj* hashList = pCmd->insertParam.pTableBlockHashList;
pCmd->insertParam.pTableBlockHashList = NULL;
- tscResetSqlCmd(pCmd, true);
+ tscResetSqlCmd(pCmd, false);
pCmd->insertParam.pTableBlockHashList = hashList;
}
@@ -1663,7 +1642,7 @@ int taos_stmt_close(TAOS_STMT* stmt) {
} else {
if (pStmt->multiTbInsert) {
taosHashCleanup(pStmt->mtb.pTableHash);
- pStmt->mtb.pTableBlockHashList = tscDestroyBlockHashTable(pStmt->mtb.pTableBlockHashList, true);
+ pStmt->mtb.pTableBlockHashList = tscDestroyBlockHashTable(pStmt->mtb.pTableBlockHashList, false);
taosHashCleanup(pStmt->pSql->cmd.insertParam.pTableBlockHashList);
pStmt->pSql->cmd.insertParam.pTableBlockHashList = NULL;
taosArrayDestroy(pStmt->mtb.tags);
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 76a56a79d0..5884d18ee7 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -65,7 +65,6 @@ static char* getAccountId(SSqlObj* pSql);
static int convertTimestampStrToInt64(tVariant *pVar, int32_t precision);
static bool serializeExprListToVariant(SArray* pList, tVariant **dest, int16_t colType, uint8_t precision);
-static int32_t validateParamOfRelationIn(tVariant *pVar, int32_t colType);
static bool has(SArray* pFieldList, int32_t startIdx, const char* name);
static char* cloneCurrentDBName(SSqlObj* pSql);
@@ -156,78 +155,78 @@ bool serializeExprListToVariant(SArray* pList, tVariant **dst, int16_t colType,
return ret;
}
- tSqlExprItem* item = (tSqlExprItem *)taosArrayGet(pList, 0);
- int32_t firstTokenType = item->pNode->token.type;
- int32_t type = firstTokenType;
+ tSqlExpr* item = ((tSqlExprItem*)(taosArrayGet(pList, 0)))->pNode;
+ int32_t firstVarType = item->value.nType;
- //nchar to binary and other xxint to bigint
- toTSDBType(type);
- if (colType != TSDB_DATA_TYPE_TIMESTAMP && !IS_UNSIGNED_NUMERIC_TYPE(colType)) {
- if (type != colType && (type != TSDB_DATA_TYPE_BINARY || colType != TSDB_DATA_TYPE_NCHAR)) {
- return false;
- }
- }
- type = colType;
-
SBufferWriter bw = tbufInitWriter( NULL, false);
-
tbufEnsureCapacity(&bw, 512);
+ if (colType == TSDB_DATA_TYPE_TIMESTAMP) {
+ tbufWriteUint32(&bw, TSDB_DATA_TYPE_BIGINT);
+ } else {
+ tbufWriteUint32(&bw, colType);
+ }
- int32_t size = (int32_t)(pList->size);
- tbufWriteUint32(&bw, type);
- tbufWriteInt32(&bw, size);
+ tbufWriteInt32(&bw, (int32_t)(pList->size));
- for (int32_t i = 0; i < size; i++) {
+ for (int32_t i = 0; i < (int32_t)pList->size; i++) {
tSqlExpr* pSub = ((tSqlExprItem*)(taosArrayGet(pList, i)))->pNode;
+ tVariant* var = &pSub->value;
// check all the token type in expr list same or not
- if (firstTokenType != pSub->token.type) {
+ if (firstVarType != var->nType) {
break;
}
- toTSDBType(pSub->token.type);
-
- tVariant var;
- tVariantCreate(&var, &pSub->token);
- if (type == TSDB_DATA_TYPE_BOOL || IS_SIGNED_NUMERIC_TYPE(type)) {
- tbufWriteInt64(&bw, var.i64);
- } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
- // ugly code, refactor later
- if (IS_UNSIGNED_NUMERIC_TYPE(pSub->token.type) || IS_SIGNED_NUMERIC_TYPE(pSub->token.type)) {
- tbufWriteUint64(&bw, var.i64);
+ if ((colType == TSDB_DATA_TYPE_BOOL || IS_SIGNED_NUMERIC_TYPE(colType))) {
+ if (var->nType != TSDB_DATA_TYPE_BOOL && !IS_SIGNED_NUMERIC_TYPE(var->nType)) {
+ break;
+ }
+ tbufWriteInt64(&bw, var->i64);
+ } else if (IS_UNSIGNED_NUMERIC_TYPE(colType)) {
+ if (IS_SIGNED_NUMERIC_TYPE(var->nType) || IS_UNSIGNED_NUMERIC_TYPE(var->nType)) {
+ tbufWriteUint64(&bw, var->u64);
} else {
- tVariantDestroy(&var);
break;
}
- }
- else if (type == TSDB_DATA_TYPE_DOUBLE || type == TSDB_DATA_TYPE_FLOAT) {
- tbufWriteDouble(&bw, var.dKey);
- } else if (type == TSDB_DATA_TYPE_BINARY){
- tbufWriteBinary(&bw, var.pz, var.nLen);
- } else if (type == TSDB_DATA_TYPE_NCHAR) {
- char *buf = (char *)calloc(1, (var.nLen + 1)*TSDB_NCHAR_SIZE);
- if (tVariantDump(&var, buf, type, false) != TSDB_CODE_SUCCESS) {
+ } else if (colType == TSDB_DATA_TYPE_DOUBLE || colType == TSDB_DATA_TYPE_FLOAT) {
+ if (IS_SIGNED_NUMERIC_TYPE(var->nType) || IS_UNSIGNED_NUMERIC_TYPE(var->nType)) {
+ tbufWriteDouble(&bw, (double)(var->i64));
+ } else if (var->nType == TSDB_DATA_TYPE_DOUBLE || var->nType == TSDB_DATA_TYPE_FLOAT){
+ tbufWriteDouble(&bw, var->dKey);
+ } else {
+ break;
+ }
+ } else if (colType == TSDB_DATA_TYPE_BINARY) {
+ if (var->nType != TSDB_DATA_TYPE_BINARY) {
+ break;
+ }
+ tbufWriteBinary(&bw, var->pz, var->nLen);
+ } else if (colType == TSDB_DATA_TYPE_NCHAR) {
+ if (var->nType != TSDB_DATA_TYPE_BINARY) {
+ break;
+ }
+ char *buf = (char *)calloc(1, (var->nLen + 1)*TSDB_NCHAR_SIZE);
+ if (tVariantDump(var, buf, colType, false) != TSDB_CODE_SUCCESS) {
free(buf);
- tVariantDestroy(&var);
break;
}
tbufWriteBinary(&bw, buf, twcslen((wchar_t *)buf) * TSDB_NCHAR_SIZE);
free(buf);
- } else if (type == TSDB_DATA_TYPE_TIMESTAMP) {
- if (var.nType == TSDB_DATA_TYPE_BINARY) {
- if (convertTimestampStrToInt64(&var, precision) < 0) {
- tVariantDestroy(&var);
+ } else if (colType == TSDB_DATA_TYPE_TIMESTAMP) {
+ if (var->nType == TSDB_DATA_TYPE_BINARY) {
+ if (convertTimestampStrToInt64(var, precision) < 0) {
break;
}
- tbufWriteInt64(&bw, var.i64);
- } else if (var.nType == TSDB_DATA_TYPE_BIGINT) {
- tbufWriteInt64(&bw, var.i64);
+ tbufWriteInt64(&bw, var->i64);
+ } else if (var->nType == TSDB_DATA_TYPE_BIGINT) {
+ tbufWriteInt64(&bw, var->i64);
+ } else {
+ break;
}
+ } else {
+ break;
}
- tVariantDestroy(&var);
-
- if (i == size - 1) { ret = true;}
- }
-
+ if (i == (int32_t)(pList->size - 1)) { ret = true;}
+ }
if (ret == true) {
if ((*dst = calloc(1, sizeof(tVariant))) != NULL) {
tVariantCreateFromBinary(*dst, tbufGetData(&bw, false), tbufTell(&bw), TSDB_DATA_TYPE_BINARY);
@@ -239,13 +238,6 @@ bool serializeExprListToVariant(SArray* pList, tVariant **dst, int16_t colType,
return ret;
}
-static int32_t validateParamOfRelationIn(tVariant *pVar, int32_t colType) {
- if (pVar->nType != TSDB_DATA_TYPE_BINARY) {
- return -1;
- }
- SBufferReader br = tbufInitReader(pVar->pz, pVar->nLen, false);
- return colType == TSDB_DATA_TYPE_NCHAR ? 0 : (tbufReadUint32(&br) == colType ? 0: -1);
-}
static uint8_t convertOptr(SStrToken *pToken) {
switch (pToken->type) {
@@ -1699,7 +1691,7 @@ static int32_t handleArithmeticExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32
// arithmetic expression always return result in the format of double float
pExprInfo->base.resBytes = sizeof(double);
- pExprInfo->base.interBytes = sizeof(double);
+ pExprInfo->base.interBytes = 0;
pExprInfo->base.resType = TSDB_DATA_TYPE_DOUBLE;
pExprInfo->base.functionId = TSDB_FUNC_ARITHM;
@@ -1934,14 +1926,14 @@ SExprInfo* doAddProjectCol(SQueryInfo* pQueryInfo, int32_t colIndex, int32_t tab
index.columnIndex = colIndex;
}
- return tscExprAppend(pQueryInfo, functionId, &index, pSchema->type, pSchema->bytes, colId, pSchema->bytes,
+ return tscExprAppend(pQueryInfo, functionId, &index, pSchema->type, pSchema->bytes, colId, 0,
(functionId == TSDB_FUNC_TAGPRJ));
}
SExprInfo* tscAddFuncInSelectClause(SQueryInfo* pQueryInfo, int32_t outputColIndex, int16_t functionId,
SColumnIndex* pIndex, SSchema* pColSchema, int16_t flag, int16_t colId) {
SExprInfo* pExpr = tscExprInsert(pQueryInfo, outputColIndex, functionId, pIndex, pColSchema->type,
- pColSchema->bytes, colId, pColSchema->bytes, TSDB_COL_IS_TAG(flag));
+ pColSchema->bytes, colId, 0, TSDB_COL_IS_TAG(flag));
tstrncpy(pExpr->base.aliasName, pColSchema->name, sizeof(pExpr->base.aliasName));
tstrncpy(pExpr->base.token, pColSchema->name, sizeof(pExpr->base.token));
@@ -2079,33 +2071,29 @@ static int32_t setExprInfoForFunctions(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SS
const char* name, int32_t resColIdx, SColumnIndex* pColIndex, bool finalResult) {
const char* msg1 = "not support column types";
- int16_t type = 0;
- int16_t bytes = 0;
- int32_t functionID = cvtFunc.execFuncId;
-
- if (functionID == TSDB_FUNC_SPREAD) {
+ int32_t f = cvtFunc.execFuncId;
+ if (f == TSDB_FUNC_SPREAD) {
int32_t t1 = pSchema->type;
- if (t1 == TSDB_DATA_TYPE_BINARY || t1 == TSDB_DATA_TYPE_NCHAR || t1 == TSDB_DATA_TYPE_BOOL) {
+ if (IS_VAR_DATA_TYPE(t1) || t1 == TSDB_DATA_TYPE_BOOL) {
invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
return -1;
- } else {
- type = TSDB_DATA_TYPE_DOUBLE;
- bytes = tDataTypes[type].bytes;
}
- } else {
- type = pSchema->type;
- bytes = pSchema->bytes;
}
-
- SExprInfo* pExpr = tscExprAppend(pQueryInfo, functionID, pColIndex, type, bytes, getNewResColId(pCmd), bytes, false);
+
+ int16_t resType = 0;
+ int16_t resBytes = 0;
+ int32_t interBufSize = 0;
+
+ getResultDataInfo(pSchema->type, pSchema->bytes, f, 0, &resType, &resBytes, &interBufSize, 0, false);
+ SExprInfo* pExpr = tscExprAppend(pQueryInfo, f, pColIndex, resType, resBytes, getNewResColId(pCmd), interBufSize, false);
tstrncpy(pExpr->base.aliasName, name, tListLen(pExpr->base.aliasName));
- if (cvtFunc.originFuncId == TSDB_FUNC_LAST_ROW && cvtFunc.originFuncId != functionID) {
+ if (cvtFunc.originFuncId == TSDB_FUNC_LAST_ROW && cvtFunc.originFuncId != f) {
pExpr->base.colInfo.flag |= TSDB_COL_NULL;
}
// set reverse order scan data blocks for last query
- if (functionID == TSDB_FUNC_LAST) {
+ if (f == TSDB_FUNC_LAST) {
pExpr->base.numOfParams = 1;
pExpr->base.param[0].i64 = TSDB_ORDER_DESC;
pExpr->base.param[0].nType = TSDB_DATA_TYPE_INT;
@@ -2118,7 +2106,7 @@ static int32_t setExprInfoForFunctions(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SS
// if it is not in the final result, do not add it
SColumnList ids = createColumnList(1, pColIndex->tableIndex, pColIndex->columnIndex);
if (finalResult) {
- insertResultField(pQueryInfo, resColIdx, &ids, bytes, (int8_t)type, pExpr->base.aliasName, pExpr);
+ insertResultField(pQueryInfo, resColIdx, &ids, resBytes, (int8_t)resType, pExpr->base.aliasName, pExpr);
} else {
tscColumnListInsert(pQueryInfo->colList, ids.ids[0].columnIndex, pExpr->base.uid, pSchema);
}
@@ -2168,6 +2156,17 @@ static void updateLastScanOrderIfNeeded(SQueryInfo* pQueryInfo) {
}
}
+static UNUSED_FUNC void updateFunctionInterBuf(SQueryInfo* pQueryInfo, bool superTable) {
+ size_t numOfExpr = tscNumOfExprs(pQueryInfo);
+ for (int32_t i = 0; i < numOfExpr; ++i) {
+ SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
+
+ int32_t param = (int32_t)pExpr->base.param[0].i64;
+ getResultDataInfo(pExpr->base.colType, pExpr->base.colBytes, pExpr->base.functionId, param, &pExpr->base.resType, &pExpr->base.resBytes,
+ &pExpr->base.interBytes, 0, superTable);
+ }
+}
+
int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t colIndex, tSqlExprItem* pItem, bool finalResult) {
STableMetaInfo* pTableMetaInfo = NULL;
int32_t functionId = pItem->pNode->functionId;
@@ -2277,10 +2276,11 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
case TSDB_FUNC_LEASTSQR: {
// 1. valid the number of parameters
int32_t numOfParams = (pItem->pNode->pParam == NULL)? 0: (int32_t) taosArrayGetSize(pItem->pNode->pParam);
+
+ // no parameters or more than one parameter for function
if (pItem->pNode->pParam == NULL ||
(functionId != TSDB_FUNC_LEASTSQR && functionId != TSDB_FUNC_DERIVATIVE && numOfParams != 1) ||
((functionId == TSDB_FUNC_LEASTSQR || functionId == TSDB_FUNC_DERIVATIVE) && numOfParams != 3)) {
- /* no parameters or more than one parameter for function */
return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
}
@@ -2294,14 +2294,15 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
}
- if (index.columnIndex == TSDB_TBNAME_COLUMN_INDEX) {
+ pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
+ STableComInfo info = tscGetTableInfo(pTableMetaInfo->pTableMeta);
+
+ // functions can not be applied to tags
+ if (index.columnIndex == TSDB_TBNAME_COLUMN_INDEX || (index.columnIndex >= tscGetNumOfColumns(pTableMetaInfo->pTableMeta))) {
return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
}
// 2. check if sql function can be applied on this column data type
- pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
- STableComInfo info = tscGetTableInfo(pTableMetaInfo->pTableMeta);
-
SSchema* pSchema = tscGetTableColumnSchema(pTableMetaInfo->pTableMeta, index.columnIndex);
if (!IS_NUMERIC_TYPE(pSchema->type)) {
@@ -2330,11 +2331,6 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
insertResultField(pQueryInfo, 0, &ids, TSDB_KEYSIZE, TSDB_DATA_TYPE_TIMESTAMP, aAggs[TSDB_FUNC_TS_DUMMY].name, pExpr);
}
- // functions can not be applied to tags
- if (index.columnIndex >= tscGetNumOfColumns(pTableMetaInfo->pTableMeta)) {
- return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
- }
-
SExprInfo* pExpr = tscExprAppend(pQueryInfo, functionId, &index, resultType, resultSize, getNewResColId(pCmd), intermediateResSize, false);
if (functionId == TSDB_FUNC_LEASTSQR) { // set the leastsquares parameters
@@ -2363,9 +2359,9 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
}
if (info.precision == TSDB_TIME_PRECISION_MILLI) {
- tickPerSec /= 1000000;
+ tickPerSec /= TSDB_TICK_PER_SECOND(TSDB_TIME_PRECISION_MICRO);
} else if (info.precision == TSDB_TIME_PRECISION_MICRO) {
- tickPerSec /= 1000;
+ tickPerSec /= TSDB_TICK_PER_SECOND(TSDB_TIME_PRECISION_MILLI);
}
if (tickPerSec <= 0 || tickPerSec < TSDB_TICK_PER_SECOND(info.precision)) {
@@ -2559,8 +2555,9 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
tVariant* pVariant = &pParamElem[1].pNode->value;
- int8_t resultType = pSchema->type;
- int16_t resultSize = pSchema->bytes;
+ int16_t resultType = pSchema->type;
+ int16_t resultSize = pSchema->bytes;
+ int32_t interResult = 0;
char val[8] = {0};
@@ -2573,8 +2570,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
}
- resultSize = sizeof(double);
- resultType = TSDB_DATA_TYPE_DOUBLE;
+ getResultDataInfo(pSchema->type, pSchema->bytes, functionId, 0, &resultType, &resultSize, &interResult, 0, false);
/*
* sql function transformation
@@ -2584,7 +2580,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
tscInsertPrimaryTsSourceColumn(pQueryInfo, pTableMetaInfo->pTableMeta->id.uid);
colIndex += 1; // the first column is ts
- pExpr = tscExprAppend(pQueryInfo, functionId, &index, resultType, resultSize, getNewResColId(pCmd), resultSize, false);
+ pExpr = tscExprAppend(pQueryInfo, functionId, &index, resultType, resultSize, getNewResColId(pCmd), interResult, false);
tscExprAddParams(&pExpr->base, val, TSDB_DATA_TYPE_DOUBLE, sizeof(double));
} else {
tVariantDump(pVariant, val, TSDB_DATA_TYPE_BIGINT, true);
@@ -2598,7 +2594,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
// set the first column ts for top/bottom query
SColumnIndex index1 = {index.tableIndex, PRIMARYKEY_TIMESTAMP_COL_INDEX};
pExpr = tscExprAppend(pQueryInfo, TSDB_FUNC_TS, &index1, TSDB_DATA_TYPE_TIMESTAMP, TSDB_KEYSIZE, getNewResColId(pCmd),
- TSDB_KEYSIZE, false);
+ 0, false);
tstrncpy(pExpr->base.aliasName, aAggs[TSDB_FUNC_TS].name, sizeof(pExpr->base.aliasName));
const int32_t TS_COLUMN_INDEX = PRIMARYKEY_TIMESTAMP_COL_INDEX;
@@ -2619,7 +2615,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
SColumnList ids = createColumnList(1, index.tableIndex, index.columnIndex);
if (finalResult) {
- insertResultField(pQueryInfo, colIndex, &ids, resultSize, resultType, pExpr->base.aliasName, pExpr);
+ insertResultField(pQueryInfo, colIndex, &ids, resultSize, (int8_t)resultType, pExpr->base.aliasName, pExpr);
} else {
assert(ids.num == 1);
tscColumnListInsert(pQueryInfo->colList, ids.ids[0].columnIndex, pExpr->base.uid, pSchema);
@@ -3113,15 +3109,10 @@ bool hasUnsupportFunctionsForSTableQuery(SSqlCmd* pCmd, SQueryInfo* pQueryInfo)
return true;
}
- if (pQueryInfo->groupbyExpr.numOfGroupCols != 1) {
+ SColIndex* pColIndex = taosArrayGet(pQueryInfo->groupbyExpr.columnInfo, 0);
+ if (pColIndex->colIndex != TSDB_TBNAME_COLUMN_INDEX) {
invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
return true;
- } else {
- SColIndex* pColIndex = taosArrayGet(pQueryInfo->groupbyExpr.columnInfo, 0);
- if (pColIndex->colIndex != TSDB_TBNAME_COLUMN_INDEX) {
- invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
- return true;
- }
}
} else if (tscIsSessionWindowQuery(pQueryInfo)) {
invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
@@ -3371,11 +3362,6 @@ static int32_t doExtractColumnFilterInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo,
if (pRight->tokenId != TK_SET || !serializeExprListToVariant(pRight->pParam, &pVal, colType, timePrecision)) {
return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
}
- if (validateParamOfRelationIn(pVal, colType) != TSDB_CODE_SUCCESS) {
- tVariantDestroy(pVal);
- free(pVal);
- return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
- }
pColumnFilter->pz = (int64_t)calloc(1, pVal->nLen + 1);
pColumnFilter->len = pVal->nLen;
pColumnFilter->filterstr = 1;
@@ -3675,7 +3661,7 @@ static int32_t checkAndSetJoinCondInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tS
STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
index.columnIndex = index.columnIndex - tscGetNumOfColumns(pTableMetaInfo->pTableMeta);
- if (!tscColumnExists(pTableMetaInfo->tagColList, index.columnIndex, pTableMetaInfo->pTableMeta->id.uid)) {
+ if (tscColumnExists(pTableMetaInfo->tagColList, pTagSchema1->colId, pTableMetaInfo->pTableMeta->id.uid) < 0) {
tscColumnListInsert(pTableMetaInfo->tagColList, index.columnIndex, pTableMeta->id.uid, pTagSchema1);
if (taosArrayGetSize(pTableMetaInfo->tagColList) > 1) {
@@ -3707,7 +3693,7 @@ static int32_t checkAndSetJoinCondInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tS
if (UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
index.columnIndex = index.columnIndex - tscGetNumOfColumns(pTableMeta);
- if (!tscColumnExists(pTableMetaInfo->tagColList, index.columnIndex, pTableMeta->id.uid)) {
+ if (tscColumnExists(pTableMetaInfo->tagColList, pTagSchema2->colId, pTableMeta->id.uid) < 0) {
tscColumnListInsert(pTableMetaInfo->tagColList, index.columnIndex, pTableMeta->id.uid, pTagSchema2);
if (taosArrayGetSize(pTableMetaInfo->tagColList) > 1) {
@@ -4831,6 +4817,12 @@ int32_t validateWhereNode(SQueryInfo* pQueryInfo, tSqlExpr** pExpr, SSqlObj* pSq
if ((ret = getColumnQueryCondInfo(&pSql->cmd, pQueryInfo, condExpr.pColumnCond, TK_AND)) != TSDB_CODE_SUCCESS) {
goto PARSE_WHERE_EXIT;
}
+
+ if (taosArrayGetSize(pQueryInfo->pUpstream) > 0 ) {
+ if ((ret = getColumnQueryCondInfo(&pSql->cmd, pQueryInfo, condExpr.pTimewindow, TK_AND)) != TSDB_CODE_SUCCESS) {
+ goto PARSE_WHERE_EXIT;
+ }
+ }
// 6. join condition
if ((ret = getJoinCondInfo(&pSql->cmd, pQueryInfo, condExpr.pJoinExpr)) != TSDB_CODE_SUCCESS) {
@@ -7818,8 +7810,9 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
const char* msg3 = "start(end) time of query range required or time range too large";
const char* msg4 = "interval query not supported, since the result of sub query not include valid timestamp column";
const char* msg5 = "only tag query not compatible with normal column filter";
- const char* msg6 = "not support stddev/percentile in outer query yet";
- const char* msg7 = "drivative requires timestamp column exists in subquery";
+ const char* msg6 = "not support stddev/percentile/interp in the outer query yet";
+ const char* msg7 = "derivative/twa/irate requires timestamp column exists in subquery";
+ const char* msg8 = "condition missing for join query";
int32_t code = TSDB_CODE_SUCCESS;
@@ -7862,15 +7855,17 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
if (validateSelectNodeList(pCmd, pQueryInfo, pSqlNode->pSelNodeList, false, false, timeWindowQuery) != TSDB_CODE_SUCCESS) {
return TSDB_CODE_TSC_INVALID_OPERATION;
}
+
// parse the window_state
if (validateStateWindowNode(pCmd, pQueryInfo, pSqlNode, false) != TSDB_CODE_SUCCESS) {
return TSDB_CODE_TSC_INVALID_OPERATION;
}
+
// todo NOT support yet
for(int32_t i = 0; i < tscNumOfExprs(pQueryInfo); ++i) {
SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
int32_t f = pExpr->base.functionId;
- if (f == TSDB_FUNC_STDDEV || f == TSDB_FUNC_PERCT) {
+ if (f == TSDB_FUNC_STDDEV || f == TSDB_FUNC_PERCT || f == TSDB_FUNC_INTERP) {
return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
}
@@ -7885,9 +7880,17 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
STableMeta* pTableMeta = tscGetMetaInfo(pQueryInfo, 0)->pTableMeta;
SSchema* pSchema = tscGetTableColumnSchema(pTableMeta, 0);
- if (tscNumOfExprs(pQueryInfo) > 1) {
+ int32_t numOfExprs = (int32_t) tscNumOfExprs(pQueryInfo);
+ if (numOfExprs == 1) {
+ SExprInfo* pExpr = tscExprGet(pQueryInfo, 0);
+ int32_t f = pExpr->base.functionId;
+ if (f == TSDB_FUNC_DERIVATIVE || f == TSDB_FUNC_TWA || f == TSDB_FUNC_IRATE) {
+ return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg7);
+ }
+ } else {
SExprInfo* pExpr = tscExprGet(pQueryInfo, 1);
- if (pExpr->base.functionId == TSDB_FUNC_DERIVATIVE && pSchema->type != TSDB_DATA_TYPE_TIMESTAMP) {
+ int32_t f = pExpr->base.functionId;
+ if ((f == TSDB_FUNC_DERIVATIVE || f == TSDB_FUNC_TWA || f == TSDB_FUNC_IRATE) && pSchema->type != TSDB_DATA_TYPE_TIMESTAMP) {
return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg7);
}
}
@@ -7897,10 +7900,9 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
if (validateWhereNode(pQueryInfo, &pSqlNode->pWhere, pSql) != TSDB_CODE_SUCCESS) {
return TSDB_CODE_TSC_INVALID_OPERATION;
}
-
- if (pTableMeta->tableInfo.precision == TSDB_TIME_PRECISION_MILLI) {
- pQueryInfo->window.skey = pQueryInfo->window.skey / 1000;
- pQueryInfo->window.ekey = pQueryInfo->window.ekey / 1000;
+ } else {
+ if (pQueryInfo->numOfTables > 1) {
+ return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg8);
}
}
@@ -7933,6 +7935,7 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
return code;
}
+// updateFunctionInterBuf(pQueryInfo, false);
updateLastScanOrderIfNeeded(pQueryInfo);
} else {
pQueryInfo->command = TSDB_SQL_SELECT;
@@ -8061,6 +8064,7 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
updateLastScanOrderIfNeeded(pQueryInfo);
tscFieldInfoUpdateOffset(pQueryInfo);
+// updateFunctionInterBuf(pQueryInfo, isSTable);
if ((code = validateFillNode(pCmd, pQueryInfo, pSqlNode)) != TSDB_CODE_SUCCESS) {
return code;
@@ -8200,7 +8204,7 @@ int32_t exprTreeFromSqlExpr(SSqlCmd* pCmd, tExprNode **pExpr, const tSqlExpr* pS
int32_t colType = -1;
STableMeta* pTableMeta = tscGetMetaInfo(pQueryInfo, 0)->pTableMeta;
if (pCols != NULL && taosArrayGetSize(pCols) > 0) {
- SColIndex* idx = taosArrayGet(pCols, 0);
+ SColIndex* idx = taosArrayGet(pCols, taosArrayGetSize(pCols) - 1);
SSchema* pSchema = tscGetTableColumnSchema(pTableMeta, idx->colIndex);
if (pSchema != NULL) {
colType = pSchema->type;
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index 8c5e99474d..7fc47947c8 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -795,6 +795,7 @@ static int32_t serializeSqlExpr(SSqlExpr* pExpr, STableMetaInfo* pTableMetaInfo,
pSqlExpr->colBytes = htons(pExpr->colBytes);
pSqlExpr->resType = htons(pExpr->resType);
pSqlExpr->resBytes = htons(pExpr->resBytes);
+ pSqlExpr->interBytes = htonl(pExpr->interBytes);
pSqlExpr->functionId = htons(pExpr->functionId);
pSqlExpr->numOfParams = htons(pExpr->numOfParams);
pSqlExpr->resColId = htons(pExpr->resColId);
@@ -1495,7 +1496,9 @@ int tscBuildAlterTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
pMsg = (char *)pSchema;
pAlterTableMsg->tagValLen = htonl(pAlterInfo->tagData.dataLen);
- memcpy(pMsg, pAlterInfo->tagData.data, pAlterInfo->tagData.dataLen);
+ if (pAlterInfo->tagData.dataLen > 0) {
+ memcpy(pMsg, pAlterInfo->tagData.data, pAlterInfo->tagData.dataLen);
+ }
pMsg += pAlterInfo->tagData.dataLen;
msgLen = (int32_t)(pMsg - (char*)pAlterTableMsg);
diff --git a/src/client/src/tscSub.c b/src/client/src/tscSub.c
index ef46b4068e..52ba424fa5 100644
--- a/src/client/src/tscSub.c
+++ b/src/client/src/tscSub.c
@@ -512,6 +512,7 @@ TAOS_RES *taos_consume(TAOS_SUB *tsub) {
pSub->pSql = pSql;
pSql->pSubscription = pSub;
+ pSub->lastSyncTime = 0;
// no table list now, force to update it
tscDebug("begin table synchronization");
diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c
index 22a603b71e..4d97fef52f 100644
--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@@ -103,13 +103,6 @@ bool subAndCheckDone(SSqlObj *pSql, SSqlObj *pParentSql, int idx) {
pthread_mutex_lock(&subState->mutex);
-// bool done = allSubqueryDone(pParentSql);
-// if (done) {
-// tscDebug("0x%"PRIx64" subquery:0x%"PRIx64",%d all subs already done", pParentSql->self, pSql->self, idx);
-// pthread_mutex_unlock(&subState->mutex);
-// return false;
-// }
-
tscDebug("0x%"PRIx64" subquery:0x%"PRIx64", index:%d state set to 1", pParentSql->self, pSql->self, idx);
subState->states[idx] = 1;
@@ -2389,8 +2382,14 @@ int32_t tscHandleFirstRoundStableQuery(SSqlObj *pSql) {
SColumn *pCol = taosArrayGetP(pColList, i);
if (pCol->info.flist.numOfFilters > 0) { // copy to the pNew->cmd.colList if it is filtered.
- SColumn *p = tscColumnClone(pCol);
- taosArrayPush(pNewQueryInfo->colList, &p);
+ int32_t index1 = tscColumnExists(pNewQueryInfo->colList, pCol->columnIndex, pCol->tableUid);
+ if (index1 >= 0) {
+ SColumn* x = taosArrayGetP(pNewQueryInfo->colList, index1);
+ tscColumnCopy(x, pCol);
+ } else {
+ SColumn *p = tscColumnClone(pCol);
+ taosArrayPush(pNewQueryInfo->colList, &p);
+ }
}
}
@@ -3605,10 +3604,10 @@ void* createQInfoFromQueryNode(SQueryInfo* pQueryInfo, STableGroupInfo* pTableGr
// todo refactor: filter should not be applied here.
createFilterInfo(pQueryAttr, 0);
- pQueryAttr->numOfFilterCols = 0;
SArray* pa = NULL;
if (stage == MASTER_SCAN) {
+ pQueryAttr->createFilterOperator = false; // no need for parent query
pa = createExecOperatorPlan(pQueryAttr);
} else {
pa = createGlobalMergePlan(pQueryAttr);
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index 9d2c500a92..6219fe23c7 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -825,7 +825,10 @@ static void fetchNextBlockIfCompleted(SOperatorInfo* pOperator, bool* newgroup)
SJoinStatus* pStatus = &pJoinInfo->status[i];
if (pStatus->pBlock == NULL || pStatus->index >= pStatus->pBlock->info.rows) {
tscDebug("Retrieve nest query result, index:%d, total:%d", i, pOperator->numOfUpstream);
+
+ publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_BEFORE_OPERATOR_EXEC);
pStatus->pBlock = pOperator->upstream[i]->exec(pOperator->upstream[i], newgroup);
+ publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_AFTER_OPERATOR_EXEC);
pStatus->index = 0;
if (pStatus->pBlock == NULL) {
@@ -1304,7 +1307,7 @@ void tscResetSqlCmd(SSqlCmd* pCmd, bool clearCachedMeta) {
if (pCmd->pTableMetaMap != NULL) {
STableMetaVgroupInfo* p = taosHashIterate(pCmd->pTableMetaMap, NULL);
while (p) {
- tfree(p->pVgroupInfo);
+ tscVgroupInfoClear(p->pVgroupInfo);
tfree(p->pTableMeta);
p = taosHashIterate(pCmd->pTableMetaMap, p);
}
@@ -1332,7 +1335,7 @@ void tscFreeSubobj(SSqlObj* pSql) {
tscDebug("0x%"PRIx64" start to free sub SqlObj, numOfSub:%d", pSql->self, pSql->subState.numOfSub);
for(int32_t i = 0; i < pSql->subState.numOfSub; ++i) {
- tscDebug("0x%"PRIx64" free sub SqlObj:%p, index:%d", pSql->self, pSql->pSubs[i], i);
+ tscDebug("0x%"PRIx64" free sub SqlObj:0x%"PRIx64", index:%d", pSql->self, pSql->pSubs[i]->self, i);
taos_free_result(pSql->pSubs[i]);
pSql->pSubs[i] = NULL;
}
@@ -1784,7 +1787,7 @@ int32_t tscMergeTableDataBlocks(SInsertStatementParam *pInsertParam, bool freeBl
tscSortRemoveDataBlockDupRows(pOneTableBlock);
char* ekey = (char*)pBlocks->data + pOneTableBlock->rowSize*(pBlocks->numOfRows-1);
- tscDebug("0x%"PRIx64" name:%s, name:%d rows:%d sversion:%d skey:%" PRId64 ", ekey:%" PRId64, pInsertParam->objectId, tNameGetTableName(&pOneTableBlock->tableName),
+ tscDebug("0x%"PRIx64" name:%s, tid:%d rows:%d sversion:%d skey:%" PRId64 ", ekey:%" PRId64, pInsertParam->objectId, tNameGetTableName(&pOneTableBlock->tableName),
pBlocks->tid, pBlocks->numOfRows, pBlocks->sversion, GET_INT64_VAL(pBlocks->data), GET_INT64_VAL(ekey));
int32_t len = pBlocks->numOfRows * (pOneTableBlock->rowSize + expandSize) + sizeof(STColumn) * tscGetNumOfColumns(pOneTableBlock->pTableMeta);
@@ -2270,18 +2273,14 @@ int32_t tscExprCopyAll(SArray* dst, const SArray* src, bool deepcopy) {
return 0;
}
-bool tscColumnExists(SArray* pColumnList, int32_t columnIndex, uint64_t uid) {
- // ignore the tbname columnIndex to be inserted into source list
- if (columnIndex < 0) {
- return false;
- }
-
+// ignore the tbname columnIndex to be inserted into source list
+int32_t tscColumnExists(SArray* pColumnList, int32_t columnId, uint64_t uid) {
size_t numOfCols = taosArrayGetSize(pColumnList);
int32_t i = 0;
while (i < numOfCols) {
SColumn* pCol = taosArrayGetP(pColumnList, i);
- if ((pCol->columnIndex != columnIndex) || (pCol->tableUid != uid)) {
+ if ((pCol->info.colId != columnId) || (pCol->tableUid != uid)) {
++i;
continue;
} else {
@@ -2290,10 +2289,10 @@ bool tscColumnExists(SArray* pColumnList, int32_t columnIndex, uint64_t uid) {
}
if (i >= numOfCols || numOfCols == 0) {
- return false;
+ return -1;
}
- return true;
+ return i;
}
void tscExprAssign(SExprInfo* dst, const SExprInfo* src) {
@@ -2379,13 +2378,7 @@ SColumn* tscColumnClone(const SColumn* src) {
return NULL;
}
- dst->columnIndex = src->columnIndex;
- dst->tableUid = src->tableUid;
- dst->info.flist.numOfFilters = src->info.flist.numOfFilters;
- dst->info.flist.filterInfo = tFilterInfoDup(src->info.flist.filterInfo, src->info.flist.numOfFilters);
- dst->info.type = src->info.type;
- dst->info.colId = src->info.colId;
- dst->info.bytes = src->info.bytes;
+ tscColumnCopy(dst, src);
return dst;
}
@@ -2394,6 +2387,18 @@ static void tscColumnDestroy(SColumn* pCol) {
free(pCol);
}
+void tscColumnCopy(SColumn* pDest, const SColumn* pSrc) {
+ destroyFilterInfo(&pDest->info.flist);
+
+ pDest->columnIndex = pSrc->columnIndex;
+ pDest->tableUid = pSrc->tableUid;
+ pDest->info.flist.numOfFilters = pSrc->info.flist.numOfFilters;
+ pDest->info.flist.filterInfo = tFilterInfoDup(pSrc->info.flist.filterInfo, pSrc->info.flist.numOfFilters);
+ pDest->info.type = pSrc->info.type;
+ pDest->info.colId = pSrc->info.colId;
+ pDest->info.bytes = pSrc->info.bytes;
+}
+
void tscColumnListCopy(SArray* dst, const SArray* src, uint64_t tableUid) {
assert(src != NULL && dst != NULL);
@@ -3276,6 +3281,8 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
pnCmd->insertParam.pTableNameList = NULL;
pnCmd->insertParam.pTableBlockHashList = NULL;
+ memset(&pnCmd->insertParam.tagData, 0, sizeof(STagData));
+
if (tscAddQueryInfo(pnCmd) != TSDB_CODE_SUCCESS) {
terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
goto _error;
@@ -4075,7 +4082,10 @@ SVgroupsInfo* tscVgroupsInfoDup(SVgroupsInfo* pVgroupsInfo) {
size_t size = sizeof(SVgroupInfo) * pVgroupsInfo->numOfVgroups + sizeof(SVgroupsInfo);
SVgroupsInfo* pInfo = calloc(1, size);
- memcpy(pInfo, pVgroupsInfo, size);
+ pInfo->numOfVgroups = pVgroupsInfo->numOfVgroups;
+ for (int32_t m = 0; m < pVgroupsInfo->numOfVgroups; ++m) {
+ tscSVgroupInfoCopy(&pInfo->vgroups[m], &pVgroupsInfo->vgroups[m]);
+ }
return pInfo;
}
diff --git a/src/client/tests/timeParseTest.cpp b/src/client/tests/timeParseTest.cpp
index 692398e3b7..3cc6d541e0 100644
--- a/src/client/tests/timeParseTest.cpp
+++ b/src/client/tests/timeParseTest.cpp
@@ -98,7 +98,7 @@ TEST(testCase, parse_time) {
taosParseTime(t41, &time, strlen(t41), TSDB_TIME_PRECISION_MILLI, 0);
EXPECT_EQ(time, 852048000999);
-// int64_t k = timezone;
+ // int64_t k = timezone;
char t42[] = "1997-1-1T0:0:0.999999999Z";
taosParseTime(t42, &time, strlen(t42), TSDB_TIME_PRECISION_MILLI, 0);
EXPECT_EQ(time, 852048000999 - timezone * MILLISECOND_PER_SECOND);
diff --git a/src/common/inc/tdataformat.h b/src/common/inc/tdataformat.h
index 8ee7329156..e3989a1deb 100644
--- a/src/common/inc/tdataformat.h
+++ b/src/common/inc/tdataformat.h
@@ -289,6 +289,11 @@ static FORCE_INLINE TKEY dataColsTKeyFirst(SDataCols *pCols) {
}
}
+static FORCE_INLINE TSKEY dataColsKeyAtRow(SDataCols *pCols, int row) {
+ ASSERT(row < pCols->numOfRows);
+ return dataColsKeyAt(pCols, row);
+}
+
static FORCE_INLINE TSKEY dataColsKeyFirst(SDataCols *pCols) {
if (pCols->numOfRows) {
return dataColsKeyAt(pCols, 0);
diff --git a/src/common/src/tdataformat.c b/src/common/src/tdataformat.c
index 7ae34d532c..94c429cfc0 100644
--- a/src/common/src/tdataformat.c
+++ b/src/common/src/tdataformat.c
@@ -452,7 +452,7 @@ int tdMergeDataCols(SDataCols *target, SDataCols *source, int rowsToMerge, int *
SDataCols *pTarget = NULL;
- if ((target->numOfRows == 0) || (dataColsKeyLast(target) < dataColsKeyFirst(source))) { // No overlap
+ if ((target->numOfRows == 0) || (dataColsKeyLast(target) < dataColsKeyAtRow(source, *pOffset))) { // No overlap
ASSERT(target->numOfRows + rowsToMerge <= target->maxPoints);
for (int i = 0; i < rowsToMerge; i++) {
for (int j = 0; j < source->numOfCols; j++) {
diff --git a/src/dnode/src/dnodeMain.c b/src/dnode/src/dnodeMain.c
index cf633502c1..61b11579bf 100644
--- a/src/dnode/src/dnodeMain.c
+++ b/src/dnode/src/dnodeMain.c
@@ -303,6 +303,8 @@ static int32_t dnodeInitStorage() {
dnodeCheckDataDirOpenned(tsDnodeDir);
+ taosGetDisk();
+ taosPrintDiskInfo();
dInfo("dnode storage is initialized at %s", tsDnodeDir);
return 0;
}
diff --git a/src/inc/taosdef.h b/src/inc/taosdef.h
index dac2dc84b6..365f24e126 100644
--- a/src/inc/taosdef.h
+++ b/src/inc/taosdef.h
@@ -100,7 +100,7 @@ extern const int32_t TYPE_BYTES[15];
#define TSDB_TIME_PRECISION_MICRO_STR "us"
#define TSDB_TIME_PRECISION_NANO_STR "ns"
-#define TSDB_TICK_PER_SECOND(precision) ((precision)==TSDB_TIME_PRECISION_MILLI ? 1e3L : ((precision)==TSDB_TIME_PRECISION_MICRO ? 1e6L : 1e9L))
+#define TSDB_TICK_PER_SECOND(precision) ((int64_t)((precision)==TSDB_TIME_PRECISION_MILLI ? 1e3L : ((precision)==TSDB_TIME_PRECISION_MICRO ? 1e6L : 1e9L)))
#define T_MEMBER_SIZE(type, member) sizeof(((type *)0)->member)
#define T_APPEND_MEMBER(dst, ptr, type, member) \
diff --git a/src/kit/taosdemo/taosdemo.c b/src/kit/taosdemo/taosdemo.c
index 33ee2a9bc2..b2ac11b2ca 100644
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
@@ -79,10 +79,9 @@ enum TEST_MODE {
#define MAX_SQL_SIZE 65536
#define BUFFER_SIZE (65536*2)
-#define COND_BUF_LEN BUFFER_SIZE - 30
+#define COND_BUF_LEN (BUFFER_SIZE - 30)
#define MAX_USERNAME_SIZE 64
#define MAX_PASSWORD_SIZE 64
-#define MAX_DB_NAME_SIZE 64
#define MAX_HOSTNAME_SIZE 64
#define MAX_TB_NAME_SIZE 64
#define MAX_DATA_SIZE (16*1024)+20 // max record len: 16*1024, timestamp string and ,('') need extra space
@@ -90,7 +89,7 @@ enum TEST_MODE {
#define OPT_ABORT 1 /* –abort */
#define STRING_LEN 60000
#define MAX_PREPARED_RAND 1000000
-#define MAX_FILE_NAME_LEN 256
+#define MAX_FILE_NAME_LEN 256 // max file name length on linux is 255.
#define MAX_SAMPLES_ONCE_FROM_FILE 10000
#define MAX_NUM_DATATYPE 10
@@ -195,13 +194,6 @@ enum _describe_table_index {
TSDB_MAX_DESCRIBE_METRIC
};
-typedef struct {
- char field[TSDB_COL_NAME_LEN + 1];
- char type[16];
- int length;
- char note[128];
-} SColDes;
-
/* Used by main to communicate with parse_opt. */
static char *g_dupstr = NULL;
@@ -247,16 +239,16 @@ typedef struct SArguments_S {
} SArguments;
typedef struct SColumn_S {
- char field[TSDB_COL_NAME_LEN + 1];
- char dataType[MAX_TB_NAME_SIZE];
+ char field[TSDB_COL_NAME_LEN];
+ char dataType[16];
uint32_t dataLen;
char note[128];
} StrColumn;
typedef struct SSuperTable_S {
- char sTblName[MAX_TB_NAME_SIZE+1];
- char dataSource[MAX_TB_NAME_SIZE+1]; // rand_gen or sample
- char childTblPrefix[MAX_TB_NAME_SIZE];
+ char sTblName[TSDB_TABLE_NAME_LEN];
+ char dataSource[MAX_TB_NAME_SIZE]; // rand_gen or sample
+ char childTblPrefix[TSDB_TABLE_NAME_LEN - 20]; // 20 characters reserved for seq
char insertMode[MAX_TB_NAME_SIZE]; // taosc, rest
uint16_t childTblExists;
int64_t childTblCount;
@@ -277,8 +269,8 @@ typedef struct SSuperTable_S {
int64_t timeStampStep;
char startTimestamp[MAX_TB_NAME_SIZE];
char sampleFormat[MAX_TB_NAME_SIZE]; // csv, json
- char sampleFile[MAX_FILE_NAME_LEN+1];
- char tagsFile[MAX_FILE_NAME_LEN+1];
+ char sampleFile[MAX_FILE_NAME_LEN];
+ char tagsFile[MAX_FILE_NAME_LEN];
uint32_t columnCount;
StrColumn columns[MAX_COLUMN_COUNT];
@@ -305,7 +297,7 @@ typedef struct SSuperTable_S {
} SSuperTable;
typedef struct {
- char name[TSDB_DB_NAME_LEN + 1];
+ char name[TSDB_DB_NAME_LEN];
char create_time[32];
int64_t ntables;
int32_t vgroups;
@@ -341,11 +333,11 @@ typedef struct SDbCfg_S {
int cache;
int blocks;
int quorum;
- char precision[MAX_TB_NAME_SIZE];
+ char precision[8];
} SDbCfg;
typedef struct SDataBase_S {
- char dbName[MAX_DB_NAME_SIZE];
+ char dbName[TSDB_DB_NAME_LEN];
bool drop; // 0: use exists, 1: if exists, drop then new create
SDbCfg dbCfg;
uint64_t superTblCount;
@@ -353,14 +345,14 @@ typedef struct SDataBase_S {
} SDataBase;
typedef struct SDbs_S {
- char cfgDir[MAX_FILE_NAME_LEN+1];
+ char cfgDir[MAX_FILE_NAME_LEN];
char host[MAX_HOSTNAME_SIZE];
struct sockaddr_in serv_addr;
uint16_t port;
char user[MAX_USERNAME_SIZE];
char password[MAX_PASSWORD_SIZE];
- char resultFile[MAX_FILE_NAME_LEN+1];
+ char resultFile[MAX_FILE_NAME_LEN];
bool use_metric;
bool insert_only;
bool do_aggreFunc;
@@ -387,7 +379,7 @@ typedef struct SpecifiedQueryInfo_S {
bool subscribeRestart;
int subscribeKeepProgress;
char sql[MAX_QUERY_SQL_COUNT][MAX_QUERY_SQL_LENGTH+1];
- char result[MAX_QUERY_SQL_COUNT][MAX_FILE_NAME_LEN+1];
+ char result[MAX_QUERY_SQL_COUNT][MAX_FILE_NAME_LEN];
int resubAfterConsume[MAX_QUERY_SQL_COUNT];
int endAfterConsume[MAX_QUERY_SQL_COUNT];
TAOS_SUB* tsub[MAX_QUERY_SQL_COUNT];
@@ -398,7 +390,7 @@ typedef struct SpecifiedQueryInfo_S {
} SpecifiedQueryInfo;
typedef struct SuperQueryInfo_S {
- char sTblName[MAX_TB_NAME_SIZE+1];
+ char sTblName[TSDB_TABLE_NAME_LEN];
uint64_t queryInterval; // 0: unlimit > 0 loop/s
uint32_t threadCnt;
uint32_t asyncMode; // 0: sync, 1: async
@@ -407,10 +399,10 @@ typedef struct SuperQueryInfo_S {
int subscribeKeepProgress;
uint64_t queryTimes;
int64_t childTblCount;
- char childTblPrefix[MAX_TB_NAME_SIZE];
+ char childTblPrefix[TSDB_TABLE_NAME_LEN - 20]; // 20 characters reserved for seq
int sqlCount;
char sql[MAX_QUERY_SQL_COUNT][MAX_QUERY_SQL_LENGTH+1];
- char result[MAX_QUERY_SQL_COUNT][MAX_FILE_NAME_LEN+1];
+ char result[MAX_QUERY_SQL_COUNT][MAX_FILE_NAME_LEN];
int resubAfterConsume;
int endAfterConsume;
TAOS_SUB* tsub[MAX_QUERY_SQL_COUNT];
@@ -420,13 +412,13 @@ typedef struct SuperQueryInfo_S {
} SuperQueryInfo;
typedef struct SQueryMetaInfo_S {
- char cfgDir[MAX_FILE_NAME_LEN+1];
+ char cfgDir[MAX_FILE_NAME_LEN];
char host[MAX_HOSTNAME_SIZE];
uint16_t port;
struct sockaddr_in serv_addr;
char user[MAX_USERNAME_SIZE];
char password[MAX_PASSWORD_SIZE];
- char dbName[MAX_DB_NAME_SIZE+1];
+ char dbName[TSDB_DB_NAME_LEN];
char queryMode[MAX_TB_NAME_SIZE]; // taosc, rest
SpecifiedQueryInfo specifiedQueryInfo;
@@ -438,11 +430,11 @@ typedef struct SThreadInfo_S {
TAOS * taos;
TAOS_STMT *stmt;
int threadID;
- char db_name[MAX_DB_NAME_SIZE+1];
+ char db_name[TSDB_DB_NAME_LEN];
uint32_t time_precision;
char filePath[4096];
FILE *fp;
- char tb_prefix[MAX_TB_NAME_SIZE];
+ char tb_prefix[TSDB_TABLE_NAME_LEN];
uint64_t start_table_from;
uint64_t end_table_to;
int64_t ntables;
@@ -608,7 +600,7 @@ SArguments g_args = {
1, // query_times
0, // interlace_rows;
30000, // num_of_RPR
- (1024*1024), // max_sql_len
+ (1024*1024), // max_sql_len
10000, // num_of_tables
10000, // num_of_DPT
0, // abort
@@ -990,9 +982,9 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
arguments->len_of_binary = atoi(argv[++i]);
} else if (strcmp(argv[i], "-m") == 0) {
if ((argc == i+1) ||
- (!isStringNumber(argv[i+1]))) {
+ (isStringNumber(argv[i+1]))) {
printHelp();
- errorPrint("%s", "\n\t-m need a number following!\n");
+ errorPrint("%s", "\n\t-m need a letter-initial string following!\n");
exit(EXIT_FAILURE);
}
arguments->tb_prefix = argv[++i];
@@ -1212,23 +1204,24 @@ static void fetchResult(TAOS_RES *res, threadInfo* pThreadInfo) {
return ;
}
- int totalLen = 0;
+ int64_t totalLen = 0;
// fetch the records row by row
while((row = taos_fetch_row(res))) {
- if ((strlen(pThreadInfo->filePath) > 0)
- && (totalLen >= 100*1024*1024 - 32000)) {
- appendResultBufToFile(databuf, pThreadInfo);
+ if (totalLen >= 100*1024*1024 - 32000) {
+ if (strlen(pThreadInfo->filePath) > 0)
+ appendResultBufToFile(databuf, pThreadInfo);
totalLen = 0;
memset(databuf, 0, 100*1024*1024);
}
num_rows++;
- char temp[16000] = {0};
+ char temp[16000] = {0};
int len = taos_print_row(temp, row, fields, num_fields);
len += sprintf(temp + len, "\n");
//printf("query result:%s\n", temp);
memcpy(databuf + totalLen, temp, len);
totalLen += len;
+ debugPrint("totalLen: %"PRId64"\n", totalLen);
}
verbosePrint("%s() LN%d, databuf=%s resultFile=%s\n",
@@ -2501,6 +2494,13 @@ static int getChildNameOfSuperTableWithLimitAndOffset(TAOS * taos,
char* pTblName = childTblName;
while((row = taos_fetch_row(res)) != NULL) {
int32_t* len = taos_fetch_lengths(res);
+
+ if (0 == strlen((char *)row[0])) {
+ errorPrint("%s() LN%d, No.%"PRId64" table return empty name\n",
+ __func__, __LINE__, count);
+ exit(-1);
+ }
+
tstrncpy(pTblName, (char *)row[0], len[0]+1);
//printf("==== sub table name: %s\n", pTblName);
count++;
@@ -3035,7 +3035,7 @@ static int startMultiThreadCreateChildTable(
for (int64_t i = 0; i < threads; i++) {
threadInfo *pThreadInfo = infos + i;
pThreadInfo->threadID = i;
- tstrncpy(pThreadInfo->db_name, db_name, MAX_DB_NAME_SIZE);
+ tstrncpy(pThreadInfo->db_name, db_name, TSDB_DB_NAME_LEN);
pThreadInfo->superTblInfo = superTblInfo;
verbosePrint("%s() %d db_name: %s\n", __func__, __LINE__, db_name);
pThreadInfo->taos = taos_connect(
@@ -3326,7 +3326,7 @@ static bool getColumnAndTagTypeFromInsertJsonFile(
goto PARSE_OVER;
}
//tstrncpy(superTbls->columns[k].dataType, dataType->valuestring, MAX_TB_NAME_SIZE);
- tstrncpy(columnCase.dataType, dataType->valuestring, MAX_TB_NAME_SIZE);
+ tstrncpy(columnCase.dataType, dataType->valuestring, strlen(dataType->valuestring) + 1);
cJSON* dataLen = cJSON_GetObjectItem(column, "len");
if (dataLen && dataLen->type == cJSON_Number) {
@@ -3341,7 +3341,7 @@ static bool getColumnAndTagTypeFromInsertJsonFile(
for (int n = 0; n < count; ++n) {
tstrncpy(superTbls->columns[index].dataType,
- columnCase.dataType, MAX_TB_NAME_SIZE);
+ columnCase.dataType, strlen(columnCase.dataType) + 1);
superTbls->columns[index].dataLen = columnCase.dataLen;
index++;
}
@@ -3397,7 +3397,7 @@ static bool getColumnAndTagTypeFromInsertJsonFile(
__func__, __LINE__);
goto PARSE_OVER;
}
- tstrncpy(columnCase.dataType, dataType->valuestring, MAX_TB_NAME_SIZE);
+ tstrncpy(columnCase.dataType, dataType->valuestring, strlen(dataType->valuestring) + 1);
cJSON* dataLen = cJSON_GetObjectItem(tag, "len");
if (dataLen && dataLen->type == cJSON_Number) {
@@ -3412,7 +3412,7 @@ static bool getColumnAndTagTypeFromInsertJsonFile(
for (int n = 0; n < count; ++n) {
tstrncpy(superTbls->tags[index].dataType, columnCase.dataType,
- MAX_TB_NAME_SIZE);
+ strlen(columnCase.dataType) + 1);
superTbls->tags[index].dataLen = columnCase.dataLen;
index++;
}
@@ -3635,7 +3635,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
printf("ERROR: failed to read json, db name not found\n");
goto PARSE_OVER;
}
- tstrncpy(g_Dbs.db[i].dbName, dbName->valuestring, MAX_DB_NAME_SIZE);
+ tstrncpy(g_Dbs.db[i].dbName, dbName->valuestring, TSDB_DB_NAME_LEN);
cJSON *drop = cJSON_GetObjectItem(dbinfo, "drop");
if (drop && drop->type == cJSON_String && drop->valuestring != NULL) {
@@ -3656,10 +3656,9 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
if (precision && precision->type == cJSON_String
&& precision->valuestring != NULL) {
tstrncpy(g_Dbs.db[i].dbCfg.precision, precision->valuestring,
- MAX_DB_NAME_SIZE);
+ 8);
} else if (!precision) {
- //tstrncpy(g_Dbs.db[i].dbCfg.precision, "ms", MAX_DB_NAME_SIZE);
- memset(g_Dbs.db[i].dbCfg.precision, 0, MAX_DB_NAME_SIZE);
+ memset(g_Dbs.db[i].dbCfg.precision, 0, 8);
} else {
printf("ERROR: failed to read json, precision not found\n");
goto PARSE_OVER;
@@ -3836,7 +3835,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
goto PARSE_OVER;
}
tstrncpy(g_Dbs.db[i].superTbls[j].sTblName, stbName->valuestring,
- MAX_TB_NAME_SIZE);
+ TSDB_TABLE_NAME_LEN);
cJSON *prefix = cJSON_GetObjectItem(stbInfo, "childtable_prefix");
if (!prefix || prefix->type != cJSON_String || prefix->valuestring == NULL) {
@@ -3844,7 +3843,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
goto PARSE_OVER;
}
tstrncpy(g_Dbs.db[i].superTbls[j].childTblPrefix, prefix->valuestring,
- MAX_DB_NAME_SIZE);
+ TSDB_TABLE_NAME_LEN - 20);
cJSON *autoCreateTbl = cJSON_GetObjectItem(stbInfo, "auto_create_table");
if (autoCreateTbl
@@ -3912,9 +3911,9 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
if (dataSource && dataSource->type == cJSON_String
&& dataSource->valuestring != NULL) {
tstrncpy(g_Dbs.db[i].superTbls[j].dataSource,
- dataSource->valuestring, MAX_DB_NAME_SIZE);
+ dataSource->valuestring, TSDB_DB_NAME_LEN);
} else if (!dataSource) {
- tstrncpy(g_Dbs.db[i].superTbls[j].dataSource, "rand", MAX_DB_NAME_SIZE);
+ tstrncpy(g_Dbs.db[i].superTbls[j].dataSource, "rand", TSDB_DB_NAME_LEN);
} else {
errorPrint("%s() LN%d, failed to read json, data_source not found\n",
__func__, __LINE__);
@@ -3972,10 +3971,10 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
cJSON *ts = cJSON_GetObjectItem(stbInfo, "start_timestamp");
if (ts && ts->type == cJSON_String && ts->valuestring != NULL) {
tstrncpy(g_Dbs.db[i].superTbls[j].startTimestamp,
- ts->valuestring, MAX_DB_NAME_SIZE);
+ ts->valuestring, TSDB_DB_NAME_LEN);
} else if (!ts) {
tstrncpy(g_Dbs.db[i].superTbls[j].startTimestamp,
- "now", MAX_DB_NAME_SIZE);
+ "now", TSDB_DB_NAME_LEN);
} else {
printf("ERROR: failed to read json, start_timestamp not found\n");
goto PARSE_OVER;
@@ -3995,9 +3994,9 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
if (sampleFormat && sampleFormat->type
== cJSON_String && sampleFormat->valuestring != NULL) {
tstrncpy(g_Dbs.db[i].superTbls[j].sampleFormat,
- sampleFormat->valuestring, MAX_DB_NAME_SIZE);
+ sampleFormat->valuestring, TSDB_DB_NAME_LEN);
} else if (!sampleFormat) {
- tstrncpy(g_Dbs.db[i].superTbls[j].sampleFormat, "csv", MAX_DB_NAME_SIZE);
+ tstrncpy(g_Dbs.db[i].superTbls[j].sampleFormat, "csv", TSDB_DB_NAME_LEN);
} else {
printf("ERROR: failed to read json, sample_format not found\n");
goto PARSE_OVER;
@@ -4242,7 +4241,7 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
cJSON* dbs = cJSON_GetObjectItem(root, "databases");
if (dbs && dbs->type == cJSON_String && dbs->valuestring != NULL) {
- tstrncpy(g_queryInfo.dbName, dbs->valuestring, MAX_DB_NAME_SIZE);
+ tstrncpy(g_queryInfo.dbName, dbs->valuestring, TSDB_DB_NAME_LEN);
} else if (!dbs) {
printf("ERROR: failed to read json, databases not found\n");
goto PARSE_OVER;
@@ -4492,7 +4491,7 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
if (stblname && stblname->type == cJSON_String
&& stblname->valuestring != NULL) {
tstrncpy(g_queryInfo.superQueryInfo.sTblName, stblname->valuestring,
- MAX_TB_NAME_SIZE);
+ TSDB_TABLE_NAME_LEN);
} else {
errorPrint("%s() LN%d, failed to read json, super table name input error\n",
__func__, __LINE__);
@@ -5103,7 +5102,7 @@ static int32_t generateStbDataTail(
} else {
retLen = getRowDataFromSample(
data,
- remainderBufLen,
+ remainderBufLen < MAX_DATA_SIZE ? remainderBufLen : MAX_DATA_SIZE,
startTime + superTblInfo->timeStampStep * k,
superTblInfo,
pSamplePos);
@@ -6302,16 +6301,6 @@ static void startMultiThreadInsertData(int threads, char* db_name,
}
}
- // read sample data from file first
- if ((superTblInfo) && (0 == strncasecmp(superTblInfo->dataSource,
- "sample", strlen("sample")))) {
- if (0 != prepareSampleDataForSTable(superTblInfo)) {
- errorPrint("%s() LN%d, prepare sample data for stable failed!\n",
- __func__, __LINE__);
- exit(-1);
- }
- }
-
TAOS* taos0 = taos_connect(
g_Dbs.host, g_Dbs.user,
g_Dbs.password, db_name, g_Dbs.port);
@@ -6417,7 +6406,7 @@ static void startMultiThreadInsertData(int threads, char* db_name,
for (int i = 0; i < threads; i++) {
threadInfo *pThreadInfo = infos + i;
pThreadInfo->threadID = i;
- tstrncpy(pThreadInfo->db_name, db_name, MAX_DB_NAME_SIZE);
+ tstrncpy(pThreadInfo->db_name, db_name, TSDB_DB_NAME_LEN);
pThreadInfo->time_precision = timePrec;
pThreadInfo->superTblInfo = superTblInfo;
@@ -6861,7 +6850,7 @@ static void *specifiedTableQuery(void *sarg) {
}
}
- char sqlStr[MAX_DB_NAME_SIZE + 5];
+ char sqlStr[TSDB_DB_NAME_LEN + 5];
sprintf(sqlStr, "use %s", g_queryInfo.dbName);
if (0 != queryDbExec(pThreadInfo->taos, sqlStr, NO_INSERT_TYPE, false)) {
taos_close(pThreadInfo->taos);
@@ -7337,12 +7326,6 @@ static void *superSubscribe(void *sarg) {
performancePrint("st: %"PRIu64" et: %"PRIu64" delta: %"PRIu64"\n", st, et, (et - st));
if (res) {
- if (g_queryInfo.superQueryInfo.result[pThreadInfo->querySeq][0] != 0) {
- sprintf(pThreadInfo->filePath, "%s-%d",
- g_queryInfo.superQueryInfo.result[pThreadInfo->querySeq],
- pThreadInfo->threadID);
- fetchResult(res, pThreadInfo);
- }
if (g_queryInfo.superQueryInfo.result[pThreadInfo->querySeq][0] != 0) {
sprintf(pThreadInfo->filePath, "%s-%d",
g_queryInfo.superQueryInfo.result[pThreadInfo->querySeq],
@@ -7449,10 +7432,10 @@ static void *specifiedSubscribe(void *sarg) {
sprintf(pThreadInfo->filePath, "%s-%d",
g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq],
pThreadInfo->threadID);
- fetchResult(
- g_queryInfo.specifiedQueryInfo.res[pThreadInfo->threadID],
- pThreadInfo);
}
+ fetchResult(
+ g_queryInfo.specifiedQueryInfo.res[pThreadInfo->threadID],
+ pThreadInfo);
g_queryInfo.specifiedQueryInfo.consumed[pThreadInfo->threadID] ++;
if ((g_queryInfo.specifiedQueryInfo.resubAfterConsume[pThreadInfo->querySeq] != -1)
@@ -7689,9 +7672,9 @@ static void setParaFromArg(){
g_Dbs.dbCount = 1;
g_Dbs.db[0].drop = true;
- tstrncpy(g_Dbs.db[0].dbName, g_args.database, MAX_DB_NAME_SIZE);
+ tstrncpy(g_Dbs.db[0].dbName, g_args.database, TSDB_DB_NAME_LEN);
g_Dbs.db[0].dbCfg.replica = g_args.replica;
- tstrncpy(g_Dbs.db[0].dbCfg.precision, "ms", MAX_DB_NAME_SIZE);
+ tstrncpy(g_Dbs.db[0].dbCfg.precision, "ms", 8);
tstrncpy(g_Dbs.resultFile, g_args.output_file, MAX_FILE_NAME_LEN);
@@ -7713,7 +7696,7 @@ static void setParaFromArg(){
if (g_args.use_metric) {
g_Dbs.db[0].superTblCount = 1;
- tstrncpy(g_Dbs.db[0].superTbls[0].sTblName, "meters", MAX_TB_NAME_SIZE);
+ 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.threadCountByCreateTbl = g_args.num_of_threads;
@@ -7724,7 +7707,7 @@ static void setParaFromArg(){
g_Dbs.db[0].superTbls[0].disorderRange = g_args.disorderRange;
g_Dbs.db[0].superTbls[0].disorderRatio = g_args.disorderRatio;
tstrncpy(g_Dbs.db[0].superTbls[0].childTblPrefix,
- g_args.tb_prefix, MAX_TB_NAME_SIZE);
+ g_args.tb_prefix, TSDB_TABLE_NAME_LEN - 20);
tstrncpy(g_Dbs.db[0].superTbls[0].dataSource, "rand", MAX_TB_NAME_SIZE);
g_Dbs.db[0].superTbls[0].iface = g_args.iface;
tstrncpy(g_Dbs.db[0].superTbls[0].startTimestamp,
@@ -7741,7 +7724,7 @@ static void setParaFromArg(){
}
tstrncpy(g_Dbs.db[0].superTbls[0].columns[i].dataType,
- data_type[i], MAX_TB_NAME_SIZE);
+ data_type[i], strlen(data_type[i]) + 1);
g_Dbs.db[0].superTbls[0].columns[i].dataLen = g_args.len_of_binary;
g_Dbs.db[0].superTbls[0].columnCount++;
}
@@ -7752,18 +7735,18 @@ static void setParaFromArg(){
for (int i = g_Dbs.db[0].superTbls[0].columnCount;
i < g_args.num_of_CPR; i++) {
tstrncpy(g_Dbs.db[0].superTbls[0].columns[i].dataType,
- "INT", MAX_TB_NAME_SIZE);
+ "INT", strlen("INT") + 1);
g_Dbs.db[0].superTbls[0].columns[i].dataLen = 0;
g_Dbs.db[0].superTbls[0].columnCount++;
}
}
tstrncpy(g_Dbs.db[0].superTbls[0].tags[0].dataType,
- "INT", MAX_TB_NAME_SIZE);
+ "INT", strlen("INT") + 1);
g_Dbs.db[0].superTbls[0].tags[0].dataLen = 0;
tstrncpy(g_Dbs.db[0].superTbls[0].tags[1].dataType,
- "BINARY", MAX_TB_NAME_SIZE);
+ "BINARY", strlen("BINARY") + 1);
g_Dbs.db[0].superTbls[0].tags[1].dataLen = g_args.len_of_binary;
g_Dbs.db[0].superTbls[0].tagCount = 2;
} else {
@@ -7899,11 +7882,11 @@ static void queryResult() {
pThreadInfo->end_table_to = g_Dbs.db[0].superTbls[0].childTblCount - 1;
pThreadInfo->superTblInfo = &g_Dbs.db[0].superTbls[0];
tstrncpy(pThreadInfo->tb_prefix,
- g_Dbs.db[0].superTbls[0].childTblPrefix, MAX_TB_NAME_SIZE);
+ g_Dbs.db[0].superTbls[0].childTblPrefix, TSDB_TABLE_NAME_LEN - 20);
} else {
pThreadInfo->ntables = g_args.num_of_tables;
pThreadInfo->end_table_to = g_args.num_of_tables -1;
- tstrncpy(pThreadInfo->tb_prefix, g_args.tb_prefix, MAX_TB_NAME_SIZE);
+ tstrncpy(pThreadInfo->tb_prefix, g_args.tb_prefix, TSDB_TABLE_NAME_LEN);
}
pThreadInfo->taos = taos_connect(
diff --git a/src/kit/taosdump/taosdump.c b/src/kit/taosdump/taosdump.c
index 165bbdf990..33118ce311 100644
--- a/src/kit/taosdump/taosdump.c
+++ b/src/kit/taosdump/taosdump.c
@@ -29,6 +29,9 @@
#define COMMAND_SIZE 65536
//#define DEFAULT_DUMP_FILE "taosdump.sql"
+// for strncpy buffer overflow
+#define min(a, b) (((a) < (b)) ? (a) : (b))
+
int converStringToReadable(char *str, int size, char *buf, int bufsize);
int convertNCharToReadable(char *str, int size, char *buf, int bufsize);
void taosDumpCharset(FILE *fp);
@@ -1119,12 +1122,11 @@ int taosGetTableDes(
TAOS_FIELD *fields = taos_fetch_fields(res);
tstrncpy(tableDes->name, table, TSDB_TABLE_NAME_LEN);
-
while ((row = taos_fetch_row(res)) != NULL) {
strncpy(tableDes->cols[count].field, (char *)row[TSDB_DESCRIBE_METRIC_FIELD_INDEX],
fields[TSDB_DESCRIBE_METRIC_FIELD_INDEX].bytes);
strncpy(tableDes->cols[count].type, (char *)row[TSDB_DESCRIBE_METRIC_TYPE_INDEX],
- fields[TSDB_DESCRIBE_METRIC_TYPE_INDEX].bytes);
+ min(15, fields[TSDB_DESCRIBE_METRIC_TYPE_INDEX].bytes));
tableDes->cols[count].length = *((int *)row[TSDB_DESCRIBE_METRIC_LENGTH_INDEX]);
strncpy(tableDes->cols[count].note, (char *)row[TSDB_DESCRIBE_METRIC_NOTE_INDEX],
fields[TSDB_DESCRIBE_METRIC_NOTE_INDEX].bytes);
@@ -1575,7 +1577,7 @@ int taosDumpDb(SDbInfo *dbInfo, struct arguments *arguments, FILE *fp, TAOS *tao
tstrncpy(tableRecord.name, (char *)row[TSDB_SHOW_TABLES_NAME_INDEX],
fields[TSDB_SHOW_TABLES_NAME_INDEX].bytes);
tstrncpy(tableRecord.metric, (char *)row[TSDB_SHOW_TABLES_METRIC_INDEX],
- fields[TSDB_SHOW_TABLES_METRIC_INDEX].bytes);
+ min(TSDB_TABLE_NAME_LEN, fields[TSDB_SHOW_TABLES_METRIC_INDEX].bytes));
taosWrite(fd, &tableRecord, sizeof(STableRecord));
diff --git a/src/mnode/src/mnodeDnode.c b/src/mnode/src/mnodeDnode.c
index a087b076a5..e3feea7d3a 100644
--- a/src/mnode/src/mnodeDnode.c
+++ b/src/mnode/src/mnodeDnode.c
@@ -101,6 +101,8 @@ static int32_t mnodeDnodeActionInsert(SSdbRow *pRow) {
pDnode->offlineReason = TAOS_DN_OFF_STATUS_NOT_RECEIVED;
}
+ pDnode->customScore = 0;
+
dnodeUpdateEp(pDnode->dnodeId, pDnode->dnodeEp, pDnode->dnodeFqdn, &pDnode->dnodePort);
mnodeUpdateDnodeEps();
@@ -1296,4 +1298,4 @@ int32_t mnodeCompactDnodes() {
mInfo("end to compact dnodes table...");
return 0;
-}
\ No newline at end of file
+}
diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c
index 032c6ee94b..20edb02c38 100644
--- a/src/mnode/src/mnodeTable.c
+++ b/src/mnode/src/mnodeTable.c
@@ -1068,7 +1068,9 @@ static int32_t mnodeProcessCreateSuperTableMsg(SMnodeMsg *pMsg) {
pStable->info.tableId = strdup(pCreate->tableName);
pStable->info.type = TSDB_SUPER_TABLE;
pStable->createdTime = taosGetTimestampMs();
- pStable->uid = (us << 24) + ((sdbGetVersion() & ((1ul << 16) - 1ul)) << 8) + (taosRand() & ((1ul << 8) - 1ul));
+ int64_t x = (us&0x000000FFFFFFFFFF);
+ x = x<<24;
+ pStable->uid = x + ((sdbGetVersion() & ((1ul << 16) - 1ul)) << 8) + (taosRand() & ((1ul << 8) - 1ul));
pStable->sversion = 0;
pStable->tversion = 0;
pStable->numOfColumns = numOfColumns;
@@ -1740,16 +1742,22 @@ static int32_t mnodeGetSuperTableMeta(SMnodeMsg *pMsg) {
return TSDB_CODE_SUCCESS;
}
-static int32_t calculateVgroupMsgLength(SSTableVgroupMsg* pInfo, int32_t numOfTable) {
+static int32_t doGetVgroupInfoLength(char* name) {
+ SSTableObj *pTable = mnodeGetSuperTable(name);
+ int32_t len = 0;
+ if (pTable != NULL && pTable->vgHash != NULL) {
+ len = (taosHashGetSize(pTable->vgHash) * sizeof(SVgroupMsg) + sizeof(SVgroupsMsg));
+ }
+
+ mnodeDecTableRef(pTable);
+ return len;
+}
+
+static int32_t getVgroupInfoLength(SSTableVgroupMsg* pInfo, int32_t numOfTable) {
int32_t contLen = sizeof(SSTableVgroupRspMsg) + 32 * sizeof(SVgroupMsg) + sizeof(SVgroupsMsg);
for (int32_t i = 0; i < numOfTable; ++i) {
char *stableName = (char *)pInfo + sizeof(SSTableVgroupMsg) + (TSDB_TABLE_FNAME_LEN)*i;
- SSTableObj *pTable = mnodeGetSuperTable(stableName);
- if (pTable != NULL && pTable->vgHash != NULL) {
- contLen += (taosHashGetSize(pTable->vgHash) * sizeof(SVgroupMsg) + sizeof(SVgroupsMsg));
- }
-
- mnodeDecTableRef(pTable);
+ contLen += doGetVgroupInfoLength(stableName);
}
return contLen;
@@ -1820,7 +1828,7 @@ static int32_t mnodeProcessSuperTableVgroupMsg(SMnodeMsg *pMsg) {
int32_t numOfTable = htonl(pInfo->numOfTables);
// calculate the required space.
- int32_t contLen = calculateVgroupMsgLength(pInfo, numOfTable);
+ int32_t contLen = getVgroupInfoLength(pInfo, numOfTable);
SSTableVgroupRspMsg *pRsp = rpcMallocCont(contLen);
if (pRsp == NULL) {
return TSDB_CODE_MND_OUT_OF_MEMORY;
@@ -2860,6 +2868,27 @@ static void mnodeProcessAlterTableRsp(SRpcMsg *rpcMsg) {
}
}
+static SMultiTableMeta* ensureMsgBufferSpace(SMultiTableMeta *pMultiMeta, SArray* pList, int32_t* totalMallocLen, int32_t numOfVgroupList) {
+ int32_t len = 0;
+ for (int32_t i = 0; i < numOfVgroupList; ++i) {
+ char *name = taosArrayGetP(pList, i);
+ len += doGetVgroupInfoLength(name);
+ }
+
+ if (len + pMultiMeta->contLen > (*totalMallocLen)) {
+ while (len + pMultiMeta->contLen > (*totalMallocLen)) {
+ (*totalMallocLen) *= 2;
+ }
+
+ pMultiMeta = rpcReallocCont(pMultiMeta, *totalMallocLen);
+ if (pMultiMeta == NULL) {
+ return NULL;
+ }
+ }
+
+ return pMultiMeta;
+}
+
static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
SMultiTableInfoMsg *pInfo = pMsg->rpcMsg.pCont;
@@ -2950,8 +2979,6 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
}
}
- char* msg = (char*) pMultiMeta + pMultiMeta->contLen;
-
// add the additional super table names that needs the vgroup info
for(;t < num; ++t) {
taosArrayPush(pList, &nameList[t]);
@@ -2961,6 +2988,13 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
int32_t numOfVgroupList = (int32_t) taosArrayGetSize(pList);
pMultiMeta->numOfVgroup = htonl(numOfVgroupList);
+ pMultiMeta = ensureMsgBufferSpace(pMultiMeta, pList, &totalMallocLen, numOfVgroupList);
+ if (pMultiMeta == NULL) {
+ code = TSDB_CODE_MND_OUT_OF_MEMORY;
+ goto _end;
+ }
+
+ char* msg = (char*) pMultiMeta + pMultiMeta->contLen;
for(int32_t i = 0; i < numOfVgroupList; ++i) {
char* name = taosArrayGetP(pList, i);
diff --git a/src/os/inc/os.h b/src/os/inc/os.h
index 6731ca6d7d..903e80d5c7 100644
--- a/src/os/inc/os.h
+++ b/src/os/inc/os.h
@@ -29,7 +29,7 @@ extern "C" {
#include "osMath.h"
#include "osMemory.h"
#include "osRand.h"
-#include "osSemphone.h"
+#include "osSemaphore.h"
#include "osSignal.h"
#include "osSleep.h"
#include "osSocket.h"
diff --git a/src/os/inc/osSemphone.h b/src/os/inc/osSemaphore.h
similarity index 97%
rename from src/os/inc/osSemphone.h
rename to src/os/inc/osSemaphore.h
index fe59095205..10d14700e0 100644
--- a/src/os/inc/osSemphone.h
+++ b/src/os/inc/osSemaphore.h
@@ -13,8 +13,8 @@
* along with this program. If not, see .
*/
-#ifndef TDENGINE_OS_SEMPHONE_H
-#define TDENGINE_OS_SEMPHONE_H
+#ifndef TDENGINE_OS_SEMAPHORE_H
+#define TDENGINE_OS_SEMAPHORE_H
#ifdef __cplusplus
extern "C" {
diff --git a/src/os/inc/osSysinfo.h b/src/os/inc/osSysinfo.h
index d136f9664c..5f0bc2950c 100644
--- a/src/os/inc/osSysinfo.h
+++ b/src/os/inc/osSysinfo.h
@@ -27,18 +27,20 @@ typedef struct {
} SysDiskSize;
int32_t taosGetDiskSize(char *dataDir, SysDiskSize *diskSize);
-void taosGetSystemInfo();
-bool taosGetProcIO(float *readKB, float *writeKB);
-bool taosGetBandSpeed(float *bandSpeedKb);
-void taosGetDisk();
-bool taosGetCpuUsage(float *sysCpuUsage, float *procCpuUsage);
-bool taosGetProcMemory(float *memoryUsedMB);
-bool taosGetSysMemory(float *memoryUsedMB);
-void taosPrintOsInfo();
-int taosSystem(const char *cmd);
-void taosKillSystem();
-bool taosGetSystemUid(char *uid);
-char * taosGetCmdlineByPID(int pid);
+
+void taosGetSystemInfo();
+bool taosGetProcIO(float *readKB, float *writeKB);
+bool taosGetBandSpeed(float *bandSpeedKb);
+void taosGetDisk();
+bool taosGetCpuUsage(float *sysCpuUsage, float *procCpuUsage) ;
+bool taosGetProcMemory(float *memoryUsedMB) ;
+bool taosGetSysMemory(float *memoryUsedMB);
+void taosPrintOsInfo();
+void taosPrintDiskInfo();
+int taosSystem(const char * cmd) ;
+void taosKillSystem();
+bool taosGetSystemUid(char *uid);
+char *taosGetCmdlineByPID(int pid);
void taosSetCoreDump();
diff --git a/src/os/src/darwin/dwSemphone.c b/src/os/src/darwin/dwSemaphore.c
similarity index 100%
rename from src/os/src/darwin/dwSemphone.c
rename to src/os/src/darwin/dwSemaphore.c
diff --git a/src/os/src/darwin/dwSysInfo.c b/src/os/src/darwin/dwSysInfo.c
index b3c9bd528e..10e0acc130 100644
--- a/src/os/src/darwin/dwSysInfo.c
+++ b/src/os/src/darwin/dwSysInfo.c
@@ -136,9 +136,6 @@ void taosPrintOsInfo() {
// uInfo(" os openMax: %" PRId64, tsOpenMax);
// uInfo(" os streamMax: %" PRId64, tsStreamMax);
uInfo(" os numOfCores: %d", tsNumOfCores);
- uInfo(" os totalDisk: %f(GB)", tsTotalDataDirGB);
- uInfo(" os usedDisk: %f(GB)", tsUsedDataDirGB);
- uInfo(" os availDisk: %f(GB)", tsAvailDataDirGB);
uInfo(" os totalMemory: %d(MB)", tsTotalMemoryMB);
struct utsname buf;
@@ -154,6 +151,14 @@ void taosPrintOsInfo() {
uInfo("==================================");
}
+void taosPrintDiskInfo() {
+ uInfo("==================================");
+ uInfo(" os totalDisk: %f(GB)", tsTotalDataDirGB);
+ uInfo(" os usedDisk: %f(GB)", tsUsedDataDirGB);
+ uInfo(" os availDisk: %f(GB)", tsAvailDataDirGB);
+ uInfo("==================================");
+}
+
void taosKillSystem() {
uError("function taosKillSystem, exit!");
exit(0);
diff --git a/src/os/src/detail/osSemphone.c b/src/os/src/detail/osSemaphore.c
similarity index 100%
rename from src/os/src/detail/osSemphone.c
rename to src/os/src/detail/osSemaphore.c
diff --git a/src/os/src/detail/osSysinfo.c b/src/os/src/detail/osSysinfo.c
index d0b284e1ca..891dccaf97 100644
--- a/src/os/src/detail/osSysinfo.c
+++ b/src/os/src/detail/osSysinfo.c
@@ -506,9 +506,6 @@ void taosPrintOsInfo() {
uInfo(" os openMax: %" PRId64, tsOpenMax);
uInfo(" os streamMax: %" PRId64, tsStreamMax);
uInfo(" os numOfCores: %d", tsNumOfCores);
- uInfo(" os totalDisk: %f(GB)", tsTotalDataDirGB);
- uInfo(" os usedDisk: %f(GB)", tsUsedDataDirGB);
- uInfo(" os availDisk: %f(GB)", tsAvailDataDirGB);
uInfo(" os totalMemory: %d(MB)", tsTotalMemoryMB);
struct utsname buf;
@@ -523,6 +520,14 @@ void taosPrintOsInfo() {
uInfo(" os machine: %s", buf.machine);
}
+void taosPrintDiskInfo() {
+ uInfo("==================================");
+ uInfo(" os totalDisk: %f(GB)", tsTotalDataDirGB);
+ uInfo(" os usedDisk: %f(GB)", tsUsedDataDirGB);
+ uInfo(" os availDisk: %f(GB)", tsAvailDataDirGB);
+ uInfo("==================================");
+}
+
void taosKillSystem() {
// SIGINT
uInfo("taosd will shut down soon");
diff --git a/src/os/src/windows/wSemphone.c b/src/os/src/windows/wSemaphore.c
similarity index 100%
rename from src/os/src/windows/wSemphone.c
rename to src/os/src/windows/wSemaphore.c
diff --git a/src/os/src/windows/wSysinfo.c b/src/os/src/windows/wSysinfo.c
index 8a81e3079a..72793a1049 100644
--- a/src/os/src/windows/wSysinfo.c
+++ b/src/os/src/windows/wSysinfo.c
@@ -205,10 +205,15 @@ void taosGetSystemInfo() {
void taosPrintOsInfo() {
uInfo(" os numOfCores: %d", tsNumOfCores);
+ uInfo(" os totalMemory: %d(MB)", tsTotalMemoryMB);
+ uInfo("==================================");
+}
+
+void taosPrintDiskInfo() {
+ uInfo("==================================");
uInfo(" os totalDisk: %f(GB)", tsTotalDataDirGB);
uInfo(" os usedDisk: %f(GB)", tsUsedDataDirGB);
uInfo(" os availDisk: %f(GB)", tsAvailDataDirGB);
- uInfo(" os totalMemory: %d(MB)", tsTotalMemoryMB);
uInfo("==================================");
}
diff --git a/src/plugins/http/src/httpGcJson.c b/src/plugins/http/src/httpGcJson.c
index 397791706d..f33a994465 100644
--- a/src/plugins/http/src/httpGcJson.c
+++ b/src/plugins/http/src/httpGcJson.c
@@ -228,13 +228,11 @@ bool gcBuildQueryJson(HttpContext *pContext, HttpSqlCmd *cmd, TAOS_RES *result,
case TSDB_DATA_TYPE_NCHAR:
httpJsonStringForTransMean(jsonBuf, (char *)row[i], fields[i].bytes);
break;
- case TSDB_DATA_TYPE_TIMESTAMP:
- if (precision == TSDB_TIME_PRECISION_MILLI) { // ms
- httpJsonInt64(jsonBuf, *((int64_t *)row[i]));
- } else {
- httpJsonInt64(jsonBuf, *((int64_t *)row[i]) / 1000);
- }
+ case TSDB_DATA_TYPE_TIMESTAMP: {
+ int64_t ts = convertTimePrecision(*((int64_t *)row[i]), precision, TSDB_TIME_PRECISION_MILLI);
+ httpJsonInt64(jsonBuf, ts);
break;
+ }
default:
httpJsonString(jsonBuf, "-", 1);
break;
diff --git a/src/query/inc/qAggMain.h b/src/query/inc/qAggMain.h
index 57e7d2982f..044c538f47 100644
--- a/src/query/inc/qAggMain.h
+++ b/src/query/inc/qAggMain.h
@@ -204,7 +204,7 @@ typedef struct SAggFunctionInfo {
bool (*init)(SQLFunctionCtx *pCtx); // setup the execute environment
void (*xFunction)(SQLFunctionCtx *pCtx); // blocks version function
- void (*xFunctionF)(SQLFunctionCtx *pCtx, int32_t position); // single-row function version, todo merge with blockwise function
+// void (*xFunctionF)(SQLFunctionCtx *pCtx, int32_t position); // single-row function version, todo merge with blockwise function
// finalizer must be called after all xFunction has been executed to generated final result.
void (*xFinalize)(SQLFunctionCtx *pCtx);
diff --git a/src/query/inc/qExecutor.h b/src/query/inc/qExecutor.h
index 955dd734cf..8279c58b24 100644
--- a/src/query/inc/qExecutor.h
+++ b/src/query/inc/qExecutor.h
@@ -133,6 +133,28 @@ typedef struct STableQueryInfo {
SResultRowInfo resInfo;
} STableQueryInfo;
+typedef enum {
+ QUERY_PROF_BEFORE_OPERATOR_EXEC = 0,
+ QUERY_PROF_AFTER_OPERATOR_EXEC,
+ QUERY_PROF_QUERY_ABORT
+} EQueryProfEventType;
+
+typedef struct {
+ EQueryProfEventType eventType;
+ int64_t eventTime;
+
+ union {
+ uint8_t operatorType; //for operator event
+ int32_t abortCode; //for query abort event
+ };
+} SQueryProfEvent;
+
+typedef struct {
+ uint8_t operatorType;
+ int64_t sumSelfTime;
+ int64_t sumRunTimes;
+} SOperatorProfResult;
+
typedef struct SQueryCostInfo {
uint64_t loadStatisTime;
uint64_t loadFileBlockTime;
@@ -154,6 +176,9 @@ typedef struct SQueryCostInfo {
uint64_t tableInfoSize;
uint64_t hashSize;
uint64_t numOfTimeWindows;
+
+ SArray* queryProfEvents; //SArray
+ SHashObj* operatorProfResults; //map
} SQueryCostInfo;
typedef struct {
@@ -192,6 +217,7 @@ typedef struct SQueryAttr {
bool needReverseScan; // need reverse scan
bool distinctTag; // distinct tag query
bool stateWindow; // window State on sub/normal table
+ bool createFilterOperator; // if filter operator is needed
int32_t interBufSize; // intermediate buffer sizse
int32_t havingNum; // having expr number
@@ -285,7 +311,7 @@ enum OPERATOR_TYPE_E {
OP_TagScan = 4,
OP_TableBlockInfoScan= 5,
OP_Aggregate = 6,
- OP_Arithmetic = 7,
+ OP_Project = 7,
OP_Groupby = 8,
OP_Limit = 9,
OP_SLimit = 10,
@@ -295,7 +321,7 @@ enum OPERATOR_TYPE_E {
OP_MultiTableAggregate = 14,
OP_MultiTableTimeInterval = 15,
OP_DummyInput = 16, //TODO remove it after fully refactor.
- OP_MultiwayMergeSort = 17, // multi-way data merge into one input stream.
+ OP_MultiwayMergeSort = 17, // multi-way data merge into one input stream.
OP_GlobalAggregate = 18, // global merge for the multi-way data sources.
OP_Filter = 19,
OP_Distinct = 20,
@@ -413,13 +439,13 @@ typedef struct SAggOperatorInfo {
uint32_t seed;
} SAggOperatorInfo;
-typedef struct SArithOperatorInfo {
+typedef struct SProjectOperatorInfo {
SOptrBasicInfo binfo;
int32_t bufCapacity;
uint32_t seed;
SSDataBlock *existDataBlock;
-} SArithOperatorInfo;
+} SProjectOperatorInfo;
typedef struct SLimitOperatorInfo {
int64_t limit;
@@ -513,7 +539,7 @@ SOperatorInfo* createTableScanOperator(void* pTsdbQueryHandle, SQueryRuntimeEnv*
SOperatorInfo* createTableSeqScanOperator(void* pTsdbQueryHandle, SQueryRuntimeEnv* pRuntimeEnv);
SOperatorInfo* createAggregateOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
-SOperatorInfo* createArithOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
+SOperatorInfo* createProjectOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
SOperatorInfo* createLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream);
SOperatorInfo* createTimeIntervalOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
SOperatorInfo* createSWindowOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
@@ -586,7 +612,12 @@ int32_t doDumpQueryResult(SQInfo *pQInfo, char *data);
size_t getResultSize(SQInfo *pQInfo, int64_t *numOfRows);
void setQueryKilled(SQInfo *pQInfo);
+
+void publishOperatorProfEvent(SOperatorInfo* operatorInfo, EQueryProfEventType eventType);
+void publishQueryAbortEvent(SQInfo* pQInfo, int32_t code);
+void calculateOperatorProfResults(SQInfo* pQInfo);
void queryCostStatis(SQInfo *pQInfo);
+
void freeQInfo(SQInfo *pQInfo);
void freeQueryAttr(SQueryAttr *pQuery);
diff --git a/src/query/inc/sql.y b/src/query/inc/sql.y
index a54d46974a..ce2c3e3616 100644
--- a/src/query/inc/sql.y
+++ b/src/query/inc/sql.y
@@ -470,7 +470,7 @@ tagitem(A) ::= PLUS(X) FLOAT(Y). {
//////////////////////// The SELECT statement /////////////////////////////////
%type select {SSqlNode*}
%destructor select {destroySqlNode($$);}
-select(A) ::= SELECT(T) selcollist(W) from(X) where_opt(Y) interval_opt(K) session_option(H) windowstate_option(D) fill_opt(F) sliding_opt(S) groupby_opt(P) orderby_opt(Z) having_opt(N) slimit_opt(G) limit_opt(L). {
+select(A) ::= SELECT(T) selcollist(W) from(X) where_opt(Y) interval_opt(K) session_option(H) windowstate_option(D) fill_opt(F) sliding_opt(S) groupby_opt(P) having_opt(N) orderby_opt(Z) slimit_opt(G) limit_opt(L). {
A = tSetQuerySqlNode(&T, W, X, Y, P, Z, &K, &H, &D, &S, F, &L, &G, N);
}
diff --git a/src/query/src/qAggMain.c b/src/query/src/qAggMain.c
index bc14c75af5..676e5b6ce6 100644
--- a/src/query/src/qAggMain.c
+++ b/src/query/src/qAggMain.c
@@ -74,7 +74,6 @@
} while (0);
void noop1(SQLFunctionCtx *UNUSED_PARAM(pCtx)) {}
-void noop2(SQLFunctionCtx *UNUSED_PARAM(pCtx), int32_t UNUSED_PARAM(index)) {}
void doFinalizer(SQLFunctionCtx *pCtx) { RESET_RESULT_INFO(GET_RES_INFO(pCtx)); }
@@ -456,20 +455,6 @@ static void count_function(SQLFunctionCtx *pCtx) {
SET_VAL(pCtx, numOfElem, 1);
}
-static void count_function_f(SQLFunctionCtx *pCtx, int32_t index) {
- char *pData = GET_INPUT_DATA(pCtx, index);
- if (pCtx->hasNull && isNull(pData, pCtx->inputType)) {
- return;
- }
-
- SET_VAL(pCtx, 1, 1);
- *((int64_t *)pCtx->pOutput) += pCtx->size;
-
- // do not need it actually
- SResultRowCellInfo *pInfo = GET_RES_INFO(pCtx);
- pInfo->hasResult = DATA_SET_FLAG;
-}
-
static void count_func_merge(SQLFunctionCtx *pCtx) {
int64_t *pData = (int64_t *)GET_INPUT_DATA_LIST(pCtx);
for (int32_t i = 0; i < pCtx->size; ++i) {
@@ -609,46 +594,6 @@ static void do_sum(SQLFunctionCtx *pCtx) {
}
}
-static void do_sum_f(SQLFunctionCtx *pCtx, int32_t index) {
- void *pData = GET_INPUT_DATA(pCtx, index);
- if (pCtx->hasNull && isNull(pData, pCtx->inputType)) {
- return;
- }
-
- SET_VAL(pCtx, 1, 1);
- int64_t *res = (int64_t*) pCtx->pOutput;
-
- if (pCtx->inputType == TSDB_DATA_TYPE_TINYINT) {
- *res += GET_INT8_VAL(pData);
- } else if (pCtx->inputType == TSDB_DATA_TYPE_SMALLINT) {
- *res += GET_INT16_VAL(pData);
- } else if (pCtx->inputType == TSDB_DATA_TYPE_INT) {
- *res += GET_INT32_VAL(pData);
- } else if (pCtx->inputType == TSDB_DATA_TYPE_BIGINT) {
- *res += GET_INT64_VAL(pData);
- } else if (pCtx->inputType == TSDB_DATA_TYPE_UTINYINT) {
- uint64_t *r = (uint64_t *)pCtx->pOutput;
- *r += GET_UINT8_VAL(pData);
- } else if (pCtx->inputType == TSDB_DATA_TYPE_USMALLINT) {
- uint64_t *r = (uint64_t *)pCtx->pOutput;
- *r += GET_UINT16_VAL(pData);
- } else if (pCtx->inputType == TSDB_DATA_TYPE_UINT) {
- uint64_t *r = (uint64_t *)pCtx->pOutput;
- *r += GET_UINT32_VAL(pData);
- } else if (pCtx->inputType == TSDB_DATA_TYPE_UBIGINT) {
- uint64_t *r = (uint64_t *)pCtx->pOutput;
- *r += GET_UINT64_VAL(pData);
- } else if (pCtx->inputType == TSDB_DATA_TYPE_DOUBLE) {
- double *retVal = (double*) pCtx->pOutput;
- *retVal += GET_DOUBLE_VAL(pData);
- } else if (pCtx->inputType == TSDB_DATA_TYPE_FLOAT) {
- double *retVal = (double*) pCtx->pOutput;
- *retVal += GET_FLOAT_VAL(pData);
- }
-
- GET_RES_INFO(pCtx)->hasResult = DATA_SET_FLAG;
-}
-
static void sum_function(SQLFunctionCtx *pCtx) {
do_sum(pCtx);
@@ -661,17 +606,6 @@ static void sum_function(SQLFunctionCtx *pCtx) {
}
}
-static void sum_function_f(SQLFunctionCtx *pCtx, int32_t index) {
- do_sum_f(pCtx, index);
-
- // keep the result data in output buffer, not in the intermediate buffer
- SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
- if (pResInfo->hasResult == DATA_SET_FLAG && pCtx->stableQuery) {
- SSumInfo *pSum = (SSumInfo *)pCtx->pOutput;
- pSum->hasResult = DATA_SET_FLAG;
- }
-}
-
static void sum_func_merge(SQLFunctionCtx *pCtx) {
int32_t notNullElems = 0;
@@ -847,53 +781,6 @@ static void avg_function(SQLFunctionCtx *pCtx) {
}
}
-static void avg_function_f(SQLFunctionCtx *pCtx, int32_t index) {
- void *pData = GET_INPUT_DATA(pCtx, index);
- if (pCtx->hasNull && isNull(pData, pCtx->inputType)) {
- return;
- }
-
- SET_VAL(pCtx, 1, 1);
-
- // NOTE: keep the intermediate result into the interResultBuf
- SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
-
- SAvgInfo *pAvgInfo = (SAvgInfo *)GET_ROWCELL_INTERBUF(pResInfo);
-
- if (pCtx->inputType == TSDB_DATA_TYPE_TINYINT) {
- pAvgInfo->sum += GET_INT8_VAL(pData);
- } else if (pCtx->inputType == TSDB_DATA_TYPE_SMALLINT) {
- pAvgInfo->sum += GET_INT16_VAL(pData);
- } else if (pCtx->inputType == TSDB_DATA_TYPE_INT) {
- pAvgInfo->sum += GET_INT32_VAL(pData);
- } else if (pCtx->inputType == TSDB_DATA_TYPE_BIGINT) {
- pAvgInfo->sum += GET_INT64_VAL(pData);
- } else if (pCtx->inputType == TSDB_DATA_TYPE_DOUBLE) {
- pAvgInfo->sum += GET_DOUBLE_VAL(pData);
- } else if (pCtx->inputType == TSDB_DATA_TYPE_FLOAT) {
- pAvgInfo->sum += GET_FLOAT_VAL(pData);
- } else if (pCtx->inputType == TSDB_DATA_TYPE_UTINYINT) {
- pAvgInfo->sum += GET_UINT8_VAL(pData);
- } else if (pCtx->inputType == TSDB_DATA_TYPE_USMALLINT) {
- pAvgInfo->sum += GET_UINT16_VAL(pData);
- } else if (pCtx->inputType == TSDB_DATA_TYPE_UINT) {
- pAvgInfo->sum += GET_UINT32_VAL(pData);
- } else if (pCtx->inputType == TSDB_DATA_TYPE_UBIGINT) {
- pAvgInfo->sum += GET_UINT64_VAL(pData);
- }
-
- // restore sum and count of elements
- pAvgInfo->num += 1;
-
- // set has result flag
- pResInfo->hasResult = DATA_SET_FLAG;
-
- // keep the data into the final output buffer for super table query since this execution may be the last one
- if (pCtx->stableQuery) {
- memcpy(pCtx->pOutput, GET_ROWCELL_INTERBUF(pResInfo), sizeof(SAvgInfo));
- }
-}
-
static void avg_func_merge(SQLFunctionCtx *pCtx) {
SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
@@ -1307,78 +1194,6 @@ static void max_func_merge(SQLFunctionCtx *pCtx) {
}
}
-static void minMax_function_f(SQLFunctionCtx *pCtx, int32_t index, int32_t isMin) {
- char *pData = GET_INPUT_DATA(pCtx, index);
- TSKEY key = GET_TS_DATA(pCtx, index);
-
- int32_t num = 0;
- if (pCtx->inputType == TSDB_DATA_TYPE_TINYINT) {
- int8_t *output = (int8_t *)pCtx->pOutput;
- int8_t i = GET_INT8_VAL(pData);
-
- UPDATE_DATA(pCtx, *output, i, num, isMin, key);
- } else if (pCtx->inputType == TSDB_DATA_TYPE_SMALLINT) {
- int16_t *output = (int16_t*) pCtx->pOutput;
- int16_t i = GET_INT16_VAL(pData);
-
- UPDATE_DATA(pCtx, *output, i, num, isMin, key);
- } else if (pCtx->inputType == TSDB_DATA_TYPE_INT) {
- int32_t *output = (int32_t*) pCtx->pOutput;
- int32_t i = GET_INT32_VAL(pData);
-
- UPDATE_DATA(pCtx, *output, i, num, isMin, key);
- } else if (pCtx->inputType == TSDB_DATA_TYPE_BIGINT) {
- int64_t *output = (int64_t*) pCtx->pOutput;
- int64_t i = GET_INT64_VAL(pData);
-
- UPDATE_DATA(pCtx, *output, i, num, isMin, key);
- } else if (pCtx->inputType == TSDB_DATA_TYPE_FLOAT) {
- float *output = (float*) pCtx->pOutput;
- float i = GET_FLOAT_VAL(pData);
-
- UPDATE_DATA(pCtx, *output, i, num, isMin, key);
- } else if (pCtx->inputType == TSDB_DATA_TYPE_DOUBLE) {
- double *output = (double*) pCtx->pOutput;
- double i = GET_DOUBLE_VAL(pData);
-
- UPDATE_DATA(pCtx, *output, i, num, isMin, key);
- }
-
- GET_RES_INFO(pCtx)->hasResult = DATA_SET_FLAG;
-}
-
-static void max_function_f(SQLFunctionCtx *pCtx, int32_t index) {
- char *pData = GET_INPUT_DATA(pCtx, index);
- if (pCtx->hasNull && isNull(pData, pCtx->inputType)) {
- return;
- }
-
- SET_VAL(pCtx, 1, 1);
- minMax_function_f(pCtx, index, 0);
-
- SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
- if (pResInfo->hasResult == DATA_SET_FLAG && pCtx->stableQuery) {
- char *flag = pCtx->pOutput + pCtx->inputBytes;
- *flag = DATA_SET_FLAG;
- }
-}
-
-static void min_function_f(SQLFunctionCtx *pCtx, int32_t index) {
- char *pData = GET_INPUT_DATA(pCtx, index);
- if (pCtx->hasNull && isNull(pData, pCtx->inputType)) {
- return;
- }
-
- SET_VAL(pCtx, 1, 1);
- minMax_function_f(pCtx, index, 1);
-
- SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
- if (pResInfo->hasResult == DATA_SET_FLAG && pCtx->stableQuery) {
- char *flag = pCtx->pOutput + pCtx->inputBytes;
- *flag = DATA_SET_FLAG;
- }
-}
-
#define LOOP_STDDEV_IMPL(type, r, d, ctx, delta, _type, num) \
for (int32_t i = 0; i < (ctx)->size; ++i) { \
if ((ctx)->hasNull && isNull((char *)&((type *)d)[i], (_type))) { \
@@ -1472,114 +1287,6 @@ static void stddev_function(SQLFunctionCtx *pCtx) {
}
}
-static void stddev_function_f(SQLFunctionCtx *pCtx, int32_t index) {
- // the second stage to calculate standard deviation
- SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
- SStddevInfo *pStd = GET_ROWCELL_INTERBUF(pResInfo);
-
- if (pCtx->currentStage == REPEAT_SCAN && pStd->stage == 0) {
- pStd->stage++;
- avg_finalizer(pCtx);
-
- pResInfo->initialized = true; // set it initialized to avoid re-initialization
-
- // save average value into tmpBuf, for second stage scan
- SAvgInfo *pAvg = GET_ROWCELL_INTERBUF(pResInfo);
-
- pStd->avg = GET_DOUBLE_VAL(pCtx->pOutput);
- assert((isnan(pAvg->sum) && pAvg->num == 0) || (pStd->num == pAvg->num && pStd->avg == pAvg->sum));
- }
-
- /* the first stage is to calculate average value */
- if (pStd->stage == 0) {
- avg_function_f(pCtx, index);
- } else if (pStd->num > 0) {
- double avg = pStd->avg;
- void * pData = GET_INPUT_DATA(pCtx, index);
-
- if (pCtx->hasNull && isNull(pData, pCtx->inputType)) {
- return;
- }
-
- switch (pCtx->inputType) {
- case TSDB_DATA_TYPE_INT: {
- pStd->res += POW2(GET_INT32_VAL(pData) - avg);
- break;
- }
- case TSDB_DATA_TYPE_FLOAT: {
- pStd->res += POW2(GET_FLOAT_VAL(pData) - avg);
- break;
- }
- case TSDB_DATA_TYPE_DOUBLE: {
- pStd->res += POW2(GET_DOUBLE_VAL(pData) - avg);
- break;
- }
- case TSDB_DATA_TYPE_BIGINT: {
- pStd->res += POW2(GET_INT64_VAL(pData) - avg);
- break;
- }
- case TSDB_DATA_TYPE_SMALLINT: {
- pStd->res += POW2(GET_INT16_VAL(pData) - avg);
- break;
- }
- case TSDB_DATA_TYPE_TINYINT: {
- pStd->res += POW2(GET_INT8_VAL(pData) - avg);
- break;
- }
- case TSDB_DATA_TYPE_UINT: {
- pStd->res += POW2(GET_UINT32_VAL(pData) - avg);
- break;
- }
- case TSDB_DATA_TYPE_UBIGINT: {
- pStd->res += POW2(GET_UINT64_VAL(pData) - avg);
- break;
- }
- case TSDB_DATA_TYPE_USMALLINT: {
- pStd->res += POW2(GET_UINT16_VAL(pData) - avg);
- break;
- }
- case TSDB_DATA_TYPE_UTINYINT: {
- pStd->res += POW2(GET_UINT8_VAL(pData) - avg);
- break;
- }
- default:
- qError("stddev function not support data type:%d", pCtx->inputType);
- }
-
- SET_VAL(pCtx, 1, 1);
- }
-}
-
-static UNUSED_FUNC void stddev_next_step(SQLFunctionCtx *pCtx) {
- /*
- * the stddevInfo and the average info struct share the same buffer area
- * And the position of each element in their struct is exactly the same matched
- */
- SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
- SStddevInfo *pStd = GET_ROWCELL_INTERBUF(pResInfo);
-
- if (pStd->stage == 0) {
- /*
- * stddev is calculated in two stage:
- * 1. get the average value of all data;
- * 2. get final result, based on the average values;
- * so, if this routine is in second stage, no further step is required
- */
- pStd->stage++;
- avg_finalizer(pCtx);
-
- pResInfo->initialized = true; // set it initialized to avoid re-initialization
-
- // save average value into tmpBuf, for second stage scan
- SAvgInfo *pAvg = GET_ROWCELL_INTERBUF(pResInfo);
-
- pStd->avg = GET_DOUBLE_VAL(pCtx->pOutput);
- assert((isnan(pAvg->sum) && pAvg->num == 0) || (pStd->num == pAvg->num && pStd->avg == pAvg->sum));
- } else {
- pResInfo->complete = true;
- }
-}
-
static void stddev_finalizer(SQLFunctionCtx *pCtx) {
SStddevInfo *pStd = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
@@ -1696,97 +1403,6 @@ static void stddev_dst_function(SQLFunctionCtx *pCtx) {
memcpy(pCtx->pOutput, GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx)), sizeof(SAvgInfo));
}
-static void stddev_dst_function_f(SQLFunctionCtx *pCtx, int32_t index) {
- void *pData = GET_INPUT_DATA(pCtx, index);
- if (pCtx->hasNull && isNull(pData, pCtx->inputType)) {
- return;
- }
-
- // the second stage to calculate standard deviation
- SStddevdstInfo *pStd = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
- double *retVal = &pStd->res;
-
- // all data are null, no need to proceed
- SArray* resList = (SArray*) pCtx->param[0].pz;
- if (resList == NULL) {
- return;
- }
-
- // find the correct group average results according to the tag value
- int32_t len = (int32_t) taosArrayGetSize(resList);
- assert(len > 0);
-
- double avg = 0;
- if (len == 1) {
- SResPair* p = taosArrayGet(resList, 0);
- avg = p->avg;
- } else { // todo opt performance by using iterator since the timestamp lsit is matched with the output result
- SResPair* p = bsearch(&pCtx->startTs, resList->pData, len, sizeof(SResPair), tsCompare);
- assert(p != NULL);
-
- avg = p->avg;
- }
-
- int32_t num = 0;
- switch (pCtx->inputType) {
- case TSDB_DATA_TYPE_INT: {
- for (int32_t i = 0; i < pCtx->size; ++i) {
- if (pCtx->hasNull && isNull((const char*) (&((int32_t *)pData)[i]), pCtx->inputType)) {
- continue;
- }
- num += 1;
- *retVal += POW2(((int32_t *)pData)[i] - avg);
- }
- break;
- }
- case TSDB_DATA_TYPE_FLOAT: {
- LOOP_STDDEV_IMPL(float, *retVal, pData, pCtx, avg, pCtx->inputType, num);
- break;
- }
- case TSDB_DATA_TYPE_DOUBLE: {
- LOOP_STDDEV_IMPL(double, *retVal, pData, pCtx, avg, pCtx->inputType, num);
- break;
- }
- case TSDB_DATA_TYPE_TINYINT: {
- LOOP_STDDEV_IMPL(int8_t, *retVal, pData, pCtx, avg, pCtx->inputType, num);
- break;
- }
- case TSDB_DATA_TYPE_UTINYINT: {
- LOOP_STDDEV_IMPL(int8_t, *retVal, pData, pCtx, avg, pCtx->inputType, num);
- break;
- }
- case TSDB_DATA_TYPE_SMALLINT: {
- LOOP_STDDEV_IMPL(int16_t, *retVal, pData, pCtx, avg, pCtx->inputType, num);
- break;
- }
- case TSDB_DATA_TYPE_USMALLINT: {
- LOOP_STDDEV_IMPL(uint16_t, *retVal, pData, pCtx, avg, pCtx->inputType, num);
- break;
- }
- case TSDB_DATA_TYPE_UINT: {
- LOOP_STDDEV_IMPL(uint32_t, *retVal, pData, pCtx, avg, pCtx->inputType, num);
- break;
- }
- case TSDB_DATA_TYPE_BIGINT: {
- LOOP_STDDEV_IMPL(int64_t, *retVal, pData, pCtx, avg, pCtx->inputType, num);
- break;
- }
- case TSDB_DATA_TYPE_UBIGINT: {
- LOOP_STDDEV_IMPL(uint64_t, *retVal, pData, pCtx, avg, pCtx->inputType, num);
- break;
- }
- default:
- qError("stddev function not support data type:%d", pCtx->inputType);
- }
-
- pStd->num += num;
- SET_VAL(pCtx, num, 1);
-
- // copy to the final output buffer for super table
- memcpy(pCtx->pOutput, GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx)), sizeof(SAvgInfo));
-}
-
-
static void stddev_dst_merge(SQLFunctionCtx *pCtx) {
SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
SStddevdstInfo* pRes = GET_ROWCELL_INTERBUF(pResInfo);
@@ -1833,7 +1449,7 @@ static bool first_last_function_setup(SQLFunctionCtx *pCtx) {
// todo opt for null block
static void first_function(SQLFunctionCtx *pCtx) {
- if (pCtx->order == TSDB_ORDER_DESC /*|| pCtx->preAggVals.dataBlockLoaded == false*/) {
+ if (pCtx->order == TSDB_ORDER_DESC) {
return;
}
@@ -1862,27 +1478,6 @@ static void first_function(SQLFunctionCtx *pCtx) {
SET_VAL(pCtx, notNullElems, 1);
}
-static void first_function_f(SQLFunctionCtx *pCtx, int32_t index) {
- if (pCtx->order == TSDB_ORDER_DESC) {
- return;
- }
-
- void *pData = GET_INPUT_DATA(pCtx, index);
- if (pCtx->hasNull && isNull(pData, pCtx->inputType)) {
- return;
- }
-
- SET_VAL(pCtx, 1, 1);
- memcpy(pCtx->pOutput, pData, pCtx->inputBytes);
-
- TSKEY ts = GET_TS_DATA(pCtx, index);
- DO_UPDATE_TAG_COLUMNS(pCtx, ts);
-
- SResultRowCellInfo *pInfo = GET_RES_INFO(pCtx);
- pInfo->hasResult = DATA_SET_FLAG;
- pInfo->complete = true; // get the first not-null data, completed
-}
-
static void first_data_assign_impl(SQLFunctionCtx *pCtx, char *pData, int32_t index) {
int64_t *timestamp = GET_TS_LIST(pCtx);
@@ -1932,21 +1527,6 @@ static void first_dist_function(SQLFunctionCtx *pCtx) {
SET_VAL(pCtx, notNullElems, 1);
}
-static void first_dist_function_f(SQLFunctionCtx *pCtx, int32_t index) {
- char *pData = GET_INPUT_DATA(pCtx, index);
- if (pCtx->hasNull && isNull(pData, pCtx->inputType)) {
- return;
- }
-
- if (pCtx->order == TSDB_ORDER_DESC) {
- return;
- }
-
- first_data_assign_impl(pCtx, pData, index);
-
- SET_VAL(pCtx, 1, 1);
-}
-
static void first_dist_func_merge(SQLFunctionCtx *pCtx) {
assert(pCtx->stableQuery);
@@ -1978,70 +1558,55 @@ static void first_dist_func_merge(SQLFunctionCtx *pCtx) {
* least one data in this block that is not null.(TODO opt for this case)
*/
static void last_function(SQLFunctionCtx *pCtx) {
- if (pCtx->order != pCtx->param[0].i64/* || pCtx->preAggVals.dataBlockLoaded == false*/) {
- return;
- }
-
- int32_t notNullElems = 0;
-
- for (int32_t i = pCtx->size - 1; i >= 0; --i) {
- char *data = GET_INPUT_DATA(pCtx, i);
- if (pCtx->hasNull && isNull(data, pCtx->inputType)) {
- if (!pCtx->requireNull) {
- continue;
- }
- }
-
- memcpy(pCtx->pOutput, data, pCtx->inputBytes);
-
- TSKEY ts = GET_TS_DATA(pCtx, i);
- DO_UPDATE_TAG_COLUMNS(pCtx, ts);
-
- SResultRowCellInfo *pInfo = GET_RES_INFO(pCtx);
- pInfo->hasResult = DATA_SET_FLAG;
-
- pInfo->complete = true; // set query completed on this column
- notNullElems++;
- break;
- }
-
- SET_VAL(pCtx, notNullElems, 1);
-}
-
-static void last_function_f(SQLFunctionCtx *pCtx, int32_t index) {
- void *pData = GET_INPUT_DATA(pCtx, index);
- if (pCtx->hasNull && isNull(pData, pCtx->inputType)) {
- return;
- }
-
- // the scan order is not the required order, ignore it
if (pCtx->order != pCtx->param[0].i64) {
return;
}
+ SResultRowCellInfo* pResInfo = GET_RES_INFO(pCtx);
+
+ int32_t notNullElems = 0;
if (pCtx->order == TSDB_ORDER_DESC) {
- SET_VAL(pCtx, 1, 1);
- memcpy(pCtx->pOutput, pData, pCtx->inputBytes);
- TSKEY ts = GET_TS_DATA(pCtx, index);
- DO_UPDATE_TAG_COLUMNS(pCtx, ts);
+ for (int32_t i = pCtx->size - 1; i >= 0; --i) {
+ char *data = GET_INPUT_DATA(pCtx, i);
+ if (pCtx->hasNull && isNull(data, pCtx->inputType) && (!pCtx->requireNull)) {
+ continue;
+ }
- SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
- pResInfo->hasResult = DATA_SET_FLAG;
- pResInfo->complete = true; // set query completed
- } else { // in case of ascending order check, all data needs to be checked
- SResultRowCellInfo* pResInfo = GET_RES_INFO(pCtx);
- TSKEY ts = GET_TS_DATA(pCtx, index);
+ memcpy(pCtx->pOutput, data, pCtx->inputBytes);
- char* buf = GET_ROWCELL_INTERBUF(pResInfo);
- if (pResInfo->hasResult != DATA_SET_FLAG || (*(TSKEY*)buf) < ts) {
- pResInfo->hasResult = DATA_SET_FLAG;
- memcpy(pCtx->pOutput, pData, pCtx->inputBytes);
-
- *(TSKEY*)buf = ts;
+ TSKEY ts = GET_TS_DATA(pCtx, i);
DO_UPDATE_TAG_COLUMNS(pCtx, ts);
+
+ pResInfo->hasResult = DATA_SET_FLAG;
+ pResInfo->complete = true; // set query completed on this column
+ notNullElems++;
+ break;
+ }
+ } else { // ascending order
+ for (int32_t i = pCtx->size - 1; i >= 0; --i) {
+ char *data = GET_INPUT_DATA(pCtx, i);
+ if (pCtx->hasNull && isNull(data, pCtx->inputType) && (!pCtx->requireNull)) {
+ continue;
+ }
+
+ TSKEY ts = GET_TS_DATA(pCtx, i);
+
+ char* buf = GET_ROWCELL_INTERBUF(pResInfo);
+ if (pResInfo->hasResult != DATA_SET_FLAG || (*(TSKEY*)buf) < ts) {
+ pResInfo->hasResult = DATA_SET_FLAG;
+ memcpy(pCtx->pOutput, data, pCtx->inputBytes);
+
+ *(TSKEY*)buf = ts;
+ DO_UPDATE_TAG_COLUMNS(pCtx, ts);
+ }
+
+ notNullElems++;
+ break;
}
}
+
+ SET_VAL(pCtx, notNullElems, 1);
}
static void last_data_assign_impl(SQLFunctionCtx *pCtx, char *pData, int32_t index) {
@@ -2092,29 +1657,6 @@ static void last_dist_function(SQLFunctionCtx *pCtx) {
SET_VAL(pCtx, notNullElems, 1);
}
-static void last_dist_function_f(SQLFunctionCtx *pCtx, int32_t index) {
- if (pCtx->size == 0) {
- return;
- }
-
- char *pData = GET_INPUT_DATA(pCtx, index);
- if (pCtx->hasNull && isNull(pData, pCtx->inputType)) {
- return;
- }
-
- /*
- * 1. for scan data in asc order, no need to check data
- * 2. for data blocks that are not loaded, no need to check data
- */
- if (pCtx->order != pCtx->param[0].i64) {
- return;
- }
-
- last_data_assign_impl(pCtx, pData, index);
-
- SET_VAL(pCtx, 1, 1);
-}
-
/*
* in the secondary merge(local reduce), the output is limited by the
* final output size, so the main difference between last_dist_func_merge and second_merge
@@ -2616,28 +2158,6 @@ static void top_function(SQLFunctionCtx *pCtx) {
}
}
-static void top_function_f(SQLFunctionCtx *pCtx, int32_t index) {
- char *pData = GET_INPUT_DATA(pCtx, index);
- if (pCtx->hasNull && isNull(pData, pCtx->inputType)) {
- return;
- }
-
- STopBotInfo *pRes = getTopBotOutputInfo(pCtx);
- assert(pRes->num >= 0);
-
- if ((void *)pRes->res[0] != (void *)((char *)pRes + sizeof(STopBotInfo) + POINTER_BYTES * pCtx->param[0].i64)) {
- buildTopBotStruct(pRes, pCtx);
- }
-
- SET_VAL(pCtx, 1, 1);
- TSKEY ts = GET_TS_DATA(pCtx, index);
-
- do_top_function_add(pRes, (int32_t)pCtx->param[0].i64, pData, ts, pCtx->inputType, &pCtx->tagInfo, NULL, 0);
-
- SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
- pResInfo->hasResult = DATA_SET_FLAG;
-}
-
static void top_func_merge(SQLFunctionCtx *pCtx) {
STopBotInfo *pInput = (STopBotInfo *)GET_INPUT_DATA_LIST(pCtx);
@@ -2695,27 +2215,6 @@ static void bottom_function(SQLFunctionCtx *pCtx) {
}
}
-static void bottom_function_f(SQLFunctionCtx *pCtx, int32_t index) {
- char *pData = GET_INPUT_DATA(pCtx, index);
- TSKEY ts = GET_TS_DATA(pCtx, index);
-
- if (pCtx->hasNull && isNull(pData, pCtx->inputType)) {
- return;
- }
-
- STopBotInfo *pRes = getTopBotOutputInfo(pCtx);
-
- if ((void *)pRes->res[0] != (void *)((char *)pRes + sizeof(STopBotInfo) + POINTER_BYTES * pCtx->param[0].i64)) {
- buildTopBotStruct(pRes, pCtx);
- }
-
- SET_VAL(pCtx, 1, 1);
- do_bottom_function_add(pRes, (int32_t)pCtx->param[0].i64, pData, ts, pCtx->inputType, &pCtx->tagInfo, NULL, 0);
-
- SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
- pResInfo->hasResult = DATA_SET_FLAG;
-}
-
static void bottom_func_merge(SQLFunctionCtx *pCtx) {
STopBotInfo *pInput = (STopBotInfo *)GET_INPUT_DATA_LIST(pCtx);
@@ -2868,50 +2367,6 @@ static void percentile_function(SQLFunctionCtx *pCtx) {
pResInfo->hasResult = DATA_SET_FLAG;
}
-static void percentile_function_f(SQLFunctionCtx *pCtx, int32_t index) {
- void *pData = GET_INPUT_DATA(pCtx, index);
- if (pCtx->hasNull && isNull(pData, pCtx->inputType)) {
- return;
- }
-
- SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
- SPercentileInfo *pInfo = (SPercentileInfo *)GET_ROWCELL_INTERBUF(pResInfo);
-
- if (pCtx->currentStage == REPEAT_SCAN && pInfo->stage == 0) {
- pInfo->stage += 1;
-
- // all data are null, set it completed
- if (pInfo->numOfElems == 0) {
- pResInfo->complete = true;
-
- return;
- } else {
- pInfo->pMemBucket = tMemBucketCreate(pCtx->inputBytes, pCtx->inputType, pInfo->minval, pInfo->maxval);
- }
- }
-
- if (pInfo->stage == 0) {
- double v = 0;
- GET_TYPED_DATA(v, double, pCtx->inputType, pData);
-
- if (v < GET_DOUBLE_VAL(&pInfo->minval)) {
- SET_DOUBLE_VAL(&pInfo->minval, v);
- }
-
- if (v > GET_DOUBLE_VAL(&pInfo->maxval)) {
- SET_DOUBLE_VAL(&pInfo->maxval, v);
- }
-
- pInfo->numOfElems += 1;
- return;
- }
-
- tMemBucketPut(pInfo->pMemBucket, pData, 1);
-
- SET_VAL(pCtx, 1, 1);
- pResInfo->hasResult = DATA_SET_FLAG;
-}
-
static void percentile_finalizer(SQLFunctionCtx *pCtx) {
double v = pCtx->param[0].nType == TSDB_DATA_TYPE_INT ? pCtx->param[0].i64 : pCtx->param[0].dKey;
@@ -2930,24 +2385,6 @@ static void percentile_finalizer(SQLFunctionCtx *pCtx) {
doFinalizer(pCtx);
}
-static UNUSED_FUNC void percentile_next_step(SQLFunctionCtx *pCtx) {
- SResultRowCellInfo * pResInfo = GET_RES_INFO(pCtx);
- SPercentileInfo *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
-
- if (pInfo->stage == 0) {
- // all data are null, set it completed
- if (pInfo->numOfElems == 0) {
- pResInfo->complete = true;
- } else {
- pInfo->pMemBucket = tMemBucketCreate(pCtx->inputBytes, pCtx->inputType, pInfo->minval, pInfo->maxval);
- }
-
- pInfo->stage += 1;
- } else {
- pResInfo->complete = true;
- }
-}
-
//////////////////////////////////////////////////////////////////////////////////
static void buildHistogramInfo(SAPercentileInfo* pInfo) {
pInfo->pHisto = (SHistogramInfo*) ((char*) pInfo + sizeof(SAPercentileInfo));
@@ -3012,24 +2449,6 @@ static void apercentile_function(SQLFunctionCtx *pCtx) {
}
}
-static void apercentile_function_f(SQLFunctionCtx *pCtx, int32_t index) {
- void *pData = GET_INPUT_DATA(pCtx, index);
- if (pCtx->hasNull && isNull(pData, pCtx->inputType)) {
- return;
- }
-
- SResultRowCellInfo * pResInfo = GET_RES_INFO(pCtx);
- SAPercentileInfo *pInfo = getAPerctInfo(pCtx);
-
- double v = 0;
- GET_TYPED_DATA(v, double, pCtx->inputType, pData);
-
- tHistogramAdd(&pInfo->pHisto, v);
-
- SET_VAL(pCtx, 1, 1);
- pResInfo->hasResult = DATA_SET_FLAG;
-}
-
static void apercentile_func_merge(SQLFunctionCtx *pCtx) {
SAPercentileInfo *pInput = (SAPercentileInfo *)GET_INPUT_DATA_LIST(pCtx);
@@ -3213,60 +2632,6 @@ static void leastsquares_function(SQLFunctionCtx *pCtx) {
SET_VAL(pCtx, numOfElem, 1);
}
-static void leastsquares_function_f(SQLFunctionCtx *pCtx, int32_t index) {
- void *pData = GET_INPUT_DATA(pCtx, index);
- if (pCtx->hasNull && isNull(pData, pCtx->inputType)) {
- return;
- }
-
- SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
- SLeastsquaresInfo *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
-
- double(*param)[3] = pInfo->mat;
-
- switch (pCtx->inputType) {
- case TSDB_DATA_TYPE_INT: {
- int32_t *p = pData;
- LEASTSQR_CAL(param, pInfo->startVal, p, 0, pCtx->param[1].dKey);
- break;
- }
- case TSDB_DATA_TYPE_TINYINT: {
- int8_t *p = pData;
- LEASTSQR_CAL(param, pInfo->startVal, p, 0, pCtx->param[1].dKey);
- break;
- }
- case TSDB_DATA_TYPE_SMALLINT: {
- int16_t *p = pData;
- LEASTSQR_CAL(param, pInfo->startVal, p, 0, pCtx->param[1].dKey);
- break;
- }
- case TSDB_DATA_TYPE_BIGINT: {
- int64_t *p = pData;
- LEASTSQR_CAL(param, pInfo->startVal, p, 0, pCtx->param[1].dKey);
- break;
- }
- case TSDB_DATA_TYPE_FLOAT: {
- float *p = pData;
- LEASTSQR_CAL(param, pInfo->startVal, p, 0, pCtx->param[1].dKey);
- break;
- }
- case TSDB_DATA_TYPE_DOUBLE: {
- double *p = pData;
- LEASTSQR_CAL(param, pInfo->startVal, p, 0, pCtx->param[1].dKey);
- break;
- }
- default:
- qError("error data type in leastsquare function:%d", pCtx->inputType);
- };
-
- SET_VAL(pCtx, 1, 1);
- pInfo->num += 1;
-
- if (pInfo->num > 0) {
- pResInfo->hasResult = DATA_SET_FLAG;
- }
-}
-
static void leastsquares_finalizer(SQLFunctionCtx *pCtx) {
// no data in query
SResultRowCellInfo * pResInfo = GET_RES_INFO(pCtx);
@@ -3304,25 +2669,23 @@ static void date_col_output_function(SQLFunctionCtx *pCtx) {
*(int64_t *)(pCtx->pOutput) = pCtx->startTs;
}
-static FORCE_INLINE void date_col_output_function_f(SQLFunctionCtx *pCtx, int32_t index) {
- date_col_output_function(pCtx);
-}
-
static void col_project_function(SQLFunctionCtx *pCtx) {
// the number of output rows should not affect the final number of rows, so set it to be 0
if (pCtx->numOfParams == 2) {
return;
}
+
+ // only one row is required.
if (pCtx->param[0].i64 == 1) {
SET_VAL(pCtx, pCtx->size, 1);
} else {
INC_INIT_VAL(pCtx, pCtx->size);
}
-
char *pData = GET_INPUT_DATA_LIST(pCtx);
if (pCtx->order == TSDB_ORDER_ASC) {
- memcpy(pCtx->pOutput, pData, (size_t) pCtx->size * pCtx->inputBytes);
+ int32_t numOfRows = (pCtx->param[0].i64 == 1)? 1:pCtx->size;
+ memcpy(pCtx->pOutput, pData, (size_t) numOfRows * pCtx->inputBytes);
} else {
for(int32_t i = 0; i < pCtx->size; ++i) {
memcpy(pCtx->pOutput + (pCtx->size - 1 - i) * pCtx->inputBytes, pData + i * pCtx->inputBytes,
@@ -3331,22 +2694,6 @@ static void col_project_function(SQLFunctionCtx *pCtx) {
}
}
-static void col_project_function_f(SQLFunctionCtx *pCtx, int32_t index) {
- SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
- if (pCtx->numOfParams == 2) { // the number of output rows should not affect the final number of rows, so set it to be 0
- return;
- }
-
- // only one output
- if (pCtx->param[0].i64 == 1 && pResInfo->numOfRes >= 1) {
- return;
- }
-
- INC_INIT_VAL(pCtx, 1);
- char *pData = GET_INPUT_DATA(pCtx, index);
- memcpy(pCtx->pOutput, pData, pCtx->inputBytes);
-}
-
/**
* only used for tag projection query in select clause
* @param pCtx
@@ -3368,13 +2715,6 @@ static void tag_project_function(SQLFunctionCtx *pCtx) {
}
}
-static void tag_project_function_f(SQLFunctionCtx *pCtx, int32_t index) {
- INC_INIT_VAL(pCtx, 1);
-
- tVariantDump(&pCtx->tag, pCtx->pOutput, pCtx->tag.nType, true);
- pCtx->pOutput += pCtx->outputBytes;
-}
-
/**
* used in group by clause. when applying group by tags, the tags value is
* assign by using tag function.
@@ -3393,11 +2733,6 @@ static void tag_function(SQLFunctionCtx *pCtx) {
}
}
-static void tag_function_f(SQLFunctionCtx *pCtx, int32_t index) {
- SET_VAL(pCtx, 1, 1);
- tVariantDump(&pCtx->tag, pCtx->pOutput, pCtx->outputType, true);
-}
-
static void copy_function(SQLFunctionCtx *pCtx) {
SET_VAL(pCtx, pCtx->size, 1);
@@ -3793,61 +3128,6 @@ static void diff_function(SQLFunctionCtx *pCtx) {
}
}
-static void diff_function_f(SQLFunctionCtx *pCtx, int32_t index) {
- char *pData = GET_INPUT_DATA(pCtx, index);
- if (pCtx->hasNull && isNull(pData, pCtx->inputType)) {
- return;
- }
-
- // the output start from the second source element
- if (pCtx->param[1].nType != INITIAL_VALUE_NOT_ASSIGNED) { // initial value is set
- GET_RES_INFO(pCtx)->numOfRes += 1;
- }
-
- int32_t step = 1/*GET_FORWARD_DIRECTION_FACTOR(pCtx->order)*/;
-
- switch (pCtx->inputType) {
- case TSDB_DATA_TYPE_INT: {
- if (pCtx->param[1].nType == INITIAL_VALUE_NOT_ASSIGNED) { // initial value is not set yet
- pCtx->param[1].nType = pCtx->inputType;
- pCtx->param[1].i64 = *(int32_t *)pData;
- } else {
- *(int32_t *)pCtx->pOutput = *(int32_t *)pData - (int32_t)pCtx->param[1].i64;
- pCtx->param[1].i64 = *(int32_t *)pData;
- *(int64_t *)pCtx->ptsOutputBuf = GET_TS_DATA(pCtx, index);
- }
- break;
- };
- case TSDB_DATA_TYPE_BIGINT: {
- DIFF_IMPL(pCtx, pData, int64_t);
- break;
- };
- case TSDB_DATA_TYPE_DOUBLE: {
- DIFF_IMPL(pCtx, pData, double);
- break;
- };
- case TSDB_DATA_TYPE_FLOAT: {
- DIFF_IMPL(pCtx, pData, float);
- break;
- };
- case TSDB_DATA_TYPE_SMALLINT: {
- DIFF_IMPL(pCtx, pData, int16_t);
- break;
- };
- case TSDB_DATA_TYPE_TINYINT: {
- DIFF_IMPL(pCtx, pData, int8_t);
- break;
- };
- default:
- qError("error input type");
- }
-
- if (GET_RES_INFO(pCtx)->numOfRes > 0) {
- pCtx->pOutput += pCtx->outputBytes * step;
- pCtx->ptsOutputBuf = (char *)pCtx->ptsOutputBuf + TSDB_KEYSIZE * step;
- }
-}
-
char *getArithColumnData(void *param, const char* name, int32_t colId) {
SArithmeticSupport *pSupport = (SArithmeticSupport *)param;
@@ -3870,16 +3150,6 @@ static void arithmetic_function(SQLFunctionCtx *pCtx) {
arithmeticTreeTraverse(sas->pExprInfo->pExpr, pCtx->size, pCtx->pOutput, sas, pCtx->order, getArithColumnData);
}
-static void arithmetic_function_f(SQLFunctionCtx *pCtx, int32_t index) {
- INC_INIT_VAL(pCtx, 1);
- SArithmeticSupport *sas = (SArithmeticSupport *)pCtx->param[1].pz;
-
- sas->offset = index;
- arithmeticTreeTraverse(sas->pExprInfo->pExpr, 1, pCtx->pOutput, sas, pCtx->order, getArithColumnData);
-
- pCtx->pOutput += pCtx->outputBytes;
-}
-
#define LIST_MINMAX_N(ctx, minOutput, maxOutput, elemCnt, data, type, tsdbType, numOfNotNullElem) \
{ \
type *inputData = (type *)data; \
@@ -3998,49 +3268,6 @@ static void spread_function(SQLFunctionCtx *pCtx) {
}
}
-static void spread_function_f(SQLFunctionCtx *pCtx, int32_t index) {
- void *pData = GET_INPUT_DATA(pCtx, index);
- if (pCtx->hasNull && isNull(pData, pCtx->inputType)) {
- return;
- }
-
- SET_VAL(pCtx, 1, 1);
-
- SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
- SSpreadInfo *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
-
- double val = 0.0;
- if (pCtx->inputType == TSDB_DATA_TYPE_TINYINT) {
- val = GET_INT8_VAL(pData);
- } else if (pCtx->inputType == TSDB_DATA_TYPE_SMALLINT) {
- val = GET_INT16_VAL(pData);
- } else if (pCtx->inputType == TSDB_DATA_TYPE_INT) {
- val = GET_INT32_VAL(pData);
- } else if (pCtx->inputType == TSDB_DATA_TYPE_BIGINT || pCtx->inputType == TSDB_DATA_TYPE_TIMESTAMP) {
- val = (double)(GET_INT64_VAL(pData));
- } else if (pCtx->inputType == TSDB_DATA_TYPE_DOUBLE) {
- val = GET_DOUBLE_VAL(pData);
- } else if (pCtx->inputType == TSDB_DATA_TYPE_FLOAT) {
- val = GET_FLOAT_VAL(pData);
- }
-
- // keep the result data in output buffer, not in the intermediate buffer
- if (val > pInfo->max) {
- pInfo->max = val;
- }
-
- if (val < pInfo->min) {
- pInfo->min = val;
- }
-
- pResInfo->hasResult = DATA_SET_FLAG;
- pInfo->hasResult = DATA_SET_FLAG;
-
- if (pCtx->stableQuery) {
- memcpy(pCtx->pOutput, GET_ROWCELL_INTERBUF(pResInfo), sizeof(SSpreadInfo));
- }
-}
-
/*
* here we set the result value back to the intermediate buffer, to apply the finalize the function
* the final result is generated in spread_function_finalizer
@@ -4393,26 +3620,6 @@ static void twa_function(SQLFunctionCtx *pCtx) {
}
}
-static void twa_function_f(SQLFunctionCtx *pCtx, int32_t index) {
- void *pData = GET_INPUT_DATA(pCtx, index);
- if (pCtx->hasNull && isNull(pData, pCtx->inputType)) {
- return;
- }
-
- int32_t notNullElems = twa_function_impl(pCtx, index, 1);
- SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
-
- SET_VAL(pCtx, notNullElems, 1);
-
- if (notNullElems > 0) {
- pResInfo->hasResult = DATA_SET_FLAG;
- }
-
- if (pCtx->stableQuery) {
- memcpy(pCtx->pOutput, GET_ROWCELL_INTERBUF(pResInfo), sizeof(STwaInfo));
- }
-}
-
/*
* To copy the input to interResBuf to avoid the input buffer space be over writen
* by next input data. The TWA function only applies to each table, so no merge procedure
@@ -4590,23 +3797,6 @@ static void ts_comp_function(SQLFunctionCtx *pCtx) {
pResInfo->hasResult = DATA_SET_FLAG;
}
-static void ts_comp_function_f(SQLFunctionCtx *pCtx, int32_t index) {
- void *pData = GET_INPUT_DATA(pCtx, index);
- if (pCtx->hasNull && isNull(pData, pCtx->inputType)) {
- return;
- }
-
- SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
- STSCompInfo *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
-
- STSBuf *pTSbuf = pInfo->pTSBuf;
-
- tsBufAppend(pTSbuf, (int32_t)pCtx->param[0].i64, &pCtx->tag, pData, TSDB_KEYSIZE);
- SET_VAL(pCtx, pCtx->size, 1);
-
- pResInfo->hasResult = DATA_SET_FLAG;
-}
-
static void ts_comp_finalize(SQLFunctionCtx *pCtx) {
SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
@@ -4736,46 +3926,6 @@ static void rate_function(SQLFunctionCtx *pCtx) {
}
}
-static void rate_function_f(SQLFunctionCtx *pCtx, int32_t index) {
- void *pData = GET_INPUT_DATA(pCtx, index);
- if (pCtx->hasNull && isNull(pData, pCtx->inputType)) {
- return;
- }
-
- // NOTE: keep the intermediate result into the interResultBuf
- SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
- SRateInfo *pRateInfo = (SRateInfo *)GET_ROWCELL_INTERBUF(pResInfo);
- TSKEY *primaryKey = GET_TS_LIST(pCtx);
-
- double v = 0;
- GET_TYPED_DATA(v, double, pCtx->inputType, pData);
-
- if ((INT64_MIN == pRateInfo->firstValue) || (INT64_MIN == pRateInfo->firstKey)) {
- pRateInfo->firstValue = v;
- pRateInfo->firstKey = primaryKey[index];
- }
-
- if (INT64_MIN == pRateInfo->lastValue) {
- pRateInfo->lastValue = v;
- } else if (v < pRateInfo->lastValue) {
- pRateInfo->correctionValue += pRateInfo->lastValue;
- }
-
- pRateInfo->lastValue = v;
- pRateInfo->lastKey = primaryKey[index];
-
- SET_VAL(pCtx, 1, 1);
-
- // set has result flag
- pRateInfo->hasResult = DATA_SET_FLAG;
- pResInfo->hasResult = DATA_SET_FLAG;
-
- // keep the data into the final output buffer for super table query since this execution may be the last one
- if (pCtx->stableQuery) {
- memcpy(pCtx->pOutput, GET_ROWCELL_INTERBUF(pResInfo), sizeof(SRateInfo));
- }
-}
-
static void rate_func_copy(SQLFunctionCtx *pCtx) {
assert(pCtx->inputType == TSDB_DATA_TYPE_BINARY);
@@ -4793,7 +3943,7 @@ static void rate_finalizer(SQLFunctionCtx *pCtx) {
return;
}
- *(double*) pCtx->pOutput = do_calc_rate(pRateInfo, TSDB_TICK_PER_SECOND(pCtx->param[0].i64));
+ *(double*) pCtx->pOutput = do_calc_rate(pRateInfo, (double) TSDB_TICK_PER_SECOND(pCtx->param[0].i64));
// cannot set the numOfIteratedElems again since it is set during previous iteration
pResInfo->numOfRes = 1;
@@ -4846,39 +3996,6 @@ static void irate_function(SQLFunctionCtx *pCtx) {
}
}
-static void irate_function_f(SQLFunctionCtx *pCtx, int32_t index) {
- void *pData = GET_INPUT_DATA(pCtx, index);
- if (pCtx->hasNull && isNull(pData, pCtx->inputType)) {
- return;
- }
-
- // NOTE: keep the intermediate result into the interResultBuf
- SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
- SRateInfo *pRateInfo = (SRateInfo *)GET_ROWCELL_INTERBUF(pResInfo);
- TSKEY *primaryKey = GET_TS_LIST(pCtx);
-
- double v = 0;
- GET_TYPED_DATA(v, double, pCtx->inputType, pData);
-
- pRateInfo->firstKey = pRateInfo->lastKey;
- pRateInfo->firstValue = pRateInfo->lastValue;
-
- pRateInfo->lastValue = v;
- pRateInfo->lastKey = primaryKey[index];
-
-// qDebug("====%p irate_function_f() index:%d lastValue:%" PRId64 " lastKey:%" PRId64 " firstValue:%" PRId64 " firstKey:%" PRId64, pCtx, index, pRateInfo->lastValue, pRateInfo->lastKey, pRateInfo->firstValue , pRateInfo->firstKey);
- SET_VAL(pCtx, 1, 1);
-
- // set has result flag
- pRateInfo->hasResult = DATA_SET_FLAG;
- pResInfo->hasResult = DATA_SET_FLAG;
-
- // keep the data into the final output buffer for super table query since this execution may be the last one
- if (pCtx->stableQuery) {
- memcpy(pCtx->pOutput, GET_ROWCELL_INTERBUF(pResInfo), sizeof(SRateInfo));
- }
-}
-
void blockInfo_func(SQLFunctionCtx* pCtx) {
SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
STableBlockDist* pDist = (STableBlockDist*) GET_ROWCELL_INTERBUF(pResInfo);
@@ -5047,8 +4164,7 @@ void blockinfo_func_finalizer(SQLFunctionCtx* pCtx) {
* function compatible list.
* tag and ts are not involved in the compatibility check
*
- * 1. functions that are not simultaneously present with any other functions. e.g.,
- * diff/ts_z/top/bottom
+ * 1. functions that are not simultaneously present with any other functions. e.g., diff/ts_z/top/bottom
* 2. functions that are only allowed to be present only with same functions. e.g., last_row, interp
* 3. functions that are allowed to be present with other functions.
* e.g., count/sum/avg/min/max/stddev/percentile/apercentile/first/last...
@@ -5062,7 +4178,7 @@ int32_t functionCompatList[] = {
// tag, colprj, tagprj, arithmetic, diff, first_dist, last_dist, stddev_dst, interp rate irate
1, 1, 1, 1, -1, 1, 1, 1, 5, 1, 1,
// tid_tag, blk_info
- 6, 7
+ 6, 7
};
SAggFunctionInfo aAggs[] = {{
@@ -5073,7 +4189,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_BASE_FUNC_SO,
function_setup,
count_function,
- count_function_f,
doFinalizer,
count_func_merge,
countRequired,
@@ -5086,7 +4201,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_BASE_FUNC_SO,
function_setup,
sum_function,
- sum_function_f,
function_finalizer,
sum_func_merge,
statisRequired,
@@ -5099,7 +4213,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_BASE_FUNC_SO,
function_setup,
avg_function,
- avg_function_f,
avg_finalizer,
avg_func_merge,
statisRequired,
@@ -5112,7 +4225,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_BASE_FUNC_SO | TSDB_FUNCSTATE_SELECTIVITY,
min_func_setup,
min_function,
- min_function_f,
function_finalizer,
min_func_merge,
statisRequired,
@@ -5125,7 +4237,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_BASE_FUNC_SO | TSDB_FUNCSTATE_SELECTIVITY,
max_func_setup,
max_function,
- max_function_f,
function_finalizer,
max_func_merge,
statisRequired,
@@ -5138,7 +4249,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_FUNCSTATE_SO | TSDB_FUNCSTATE_STREAM | TSDB_FUNCSTATE_OF,
function_setup,
stddev_function,
- stddev_function_f,
stddev_finalizer,
noop1,
dataBlockRequired,
@@ -5151,7 +4261,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_FUNCSTATE_SO | TSDB_FUNCSTATE_STREAM | TSDB_FUNCSTATE_OF,
percentile_function_setup,
percentile_function,
- percentile_function_f,
percentile_finalizer,
noop1,
dataBlockRequired,
@@ -5164,7 +4273,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_FUNCSTATE_SO | TSDB_FUNCSTATE_STREAM | TSDB_FUNCSTATE_OF | TSDB_FUNCSTATE_STABLE,
apercentile_function_setup,
apercentile_function,
- apercentile_function_f,
apercentile_finalizer,
apercentile_func_merge,
dataBlockRequired,
@@ -5177,7 +4285,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_BASE_FUNC_SO | TSDB_FUNCSTATE_SELECTIVITY,
function_setup,
first_function,
- first_function_f,
function_finalizer,
noop1,
firstFuncRequired,
@@ -5190,7 +4297,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_BASE_FUNC_SO | TSDB_FUNCSTATE_SELECTIVITY,
function_setup,
last_function,
- last_function_f,
function_finalizer,
noop1,
lastFuncRequired,
@@ -5204,7 +4310,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_FUNCSTATE_SELECTIVITY,
first_last_function_setup,
last_row_function,
- noop2,
last_row_finalizer,
last_dist_func_merge,
dataBlockRequired,
@@ -5218,7 +4323,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_FUNCSTATE_SELECTIVITY,
top_bottom_function_setup,
top_function,
- top_function_f,
top_bottom_func_finalizer,
top_func_merge,
dataBlockRequired,
@@ -5232,7 +4336,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_FUNCSTATE_SELECTIVITY,
top_bottom_function_setup,
bottom_function,
- bottom_function_f,
top_bottom_func_finalizer,
bottom_func_merge,
dataBlockRequired,
@@ -5245,7 +4348,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_BASE_FUNC_SO,
spread_function_setup,
spread_function,
- spread_function_f,
spread_function_finalizer,
spread_func_merge,
countRequired,
@@ -5258,7 +4360,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_BASE_FUNC_SO | TSDB_FUNCSTATE_NEED_TS,
twa_function_setup,
twa_function,
- twa_function_f,
twa_function_finalizer,
twa_function_copy,
dataBlockRequired,
@@ -5271,7 +4372,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_FUNCSTATE_SO | TSDB_FUNCSTATE_STREAM | TSDB_FUNCSTATE_OF,
leastsquares_function_setup,
leastsquares_function,
- leastsquares_function_f,
leastsquares_finalizer,
noop1,
dataBlockRequired,
@@ -5284,7 +4384,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_BASE_FUNC_SO | TSDB_FUNCSTATE_NEED_TS,
function_setup,
date_col_output_function,
- date_col_output_function_f,
doFinalizer,
copy_function,
noDataRequired,
@@ -5297,7 +4396,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_BASE_FUNC_SO | TSDB_FUNCSTATE_NEED_TS,
function_setup,
noop1,
- noop2,
doFinalizer,
copy_function,
dataBlockRequired,
@@ -5310,7 +4408,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_BASE_FUNC_SO,
function_setup,
tag_function,
- noop2,
doFinalizer,
copy_function,
noDataRequired,
@@ -5323,7 +4420,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_FUNCSTATE_MO | TSDB_FUNCSTATE_NEED_TS,
ts_comp_function_setup,
ts_comp_function,
- ts_comp_function_f,
ts_comp_finalize,
copy_function,
dataBlockRequired,
@@ -5336,7 +4432,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_BASE_FUNC_SO,
function_setup,
tag_function,
- tag_function_f,
doFinalizer,
copy_function,
noDataRequired,
@@ -5349,7 +4444,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_BASE_FUNC_MO | TSDB_FUNCSTATE_NEED_TS,
function_setup,
col_project_function,
- col_project_function_f,
doFinalizer,
copy_function,
dataBlockRequired,
@@ -5362,7 +4456,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_BASE_FUNC_MO,
function_setup,
tag_project_function,
- tag_project_function_f,
doFinalizer,
copy_function,
noDataRequired,
@@ -5375,7 +4468,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_FUNCSTATE_MO | TSDB_FUNCSTATE_STABLE | TSDB_FUNCSTATE_NEED_TS,
function_setup,
arithmetic_function,
- arithmetic_function_f,
doFinalizer,
copy_function,
dataBlockRequired,
@@ -5388,7 +4480,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_FUNCSTATE_MO | TSDB_FUNCSTATE_STABLE | TSDB_FUNCSTATE_NEED_TS | TSDB_FUNCSTATE_SELECTIVITY,
diff_function_setup,
diff_function,
- diff_function_f,
doFinalizer,
noop1,
dataBlockRequired,
@@ -5402,7 +4493,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_BASE_FUNC_SO | TSDB_FUNCSTATE_NEED_TS | TSDB_FUNCSTATE_SELECTIVITY,
first_last_function_setup,
first_dist_function,
- first_dist_function_f,
function_finalizer,
first_dist_func_merge,
firstDistFuncRequired,
@@ -5415,7 +4505,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_BASE_FUNC_SO | TSDB_FUNCSTATE_NEED_TS | TSDB_FUNCSTATE_SELECTIVITY,
first_last_function_setup,
last_dist_function,
- last_dist_function_f,
function_finalizer,
last_dist_func_merge,
lastDistFuncRequired,
@@ -5428,7 +4517,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_FUNCSTATE_SO | TSDB_FUNCSTATE_STABLE,
function_setup,
stddev_dst_function,
- stddev_dst_function_f,
stddev_dst_finalizer,
stddev_dst_merge,
dataBlockRequired,
@@ -5441,7 +4529,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_FUNCSTATE_SO | TSDB_FUNCSTATE_OF | TSDB_FUNCSTATE_STABLE | TSDB_FUNCSTATE_NEED_TS ,
function_setup,
interp_function,
- do_sum_f, // todo filter handle
doFinalizer,
copy_function,
dataBlockRequired,
@@ -5454,7 +4541,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_BASE_FUNC_SO | TSDB_FUNCSTATE_NEED_TS,
rate_function_setup,
rate_function,
- rate_function_f,
rate_finalizer,
rate_func_copy,
dataBlockRequired,
@@ -5467,7 +4553,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_BASE_FUNC_SO | TSDB_FUNCSTATE_NEED_TS,
rate_function_setup,
irate_function,
- irate_function_f,
rate_finalizer,
rate_func_copy,
dataBlockRequired,
@@ -5480,7 +4565,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_FUNCSTATE_MO | TSDB_FUNCSTATE_STABLE,
function_setup,
noop1,
- noop2,
noop1,
noop1,
dataBlockRequired,
@@ -5492,7 +4576,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_FUNCSTATE_MO | TSDB_FUNCSTATE_STABLE | TSDB_FUNCSTATE_NEED_TS | TSDB_FUNCSTATE_SELECTIVITY,
deriv_function_setup,
deriv_function,
- noop2,
doFinalizer,
noop1,
dataBlockRequired,
@@ -5505,7 +4588,6 @@ SAggFunctionInfo aAggs[] = {{
TSDB_FUNCSTATE_SO | TSDB_FUNCSTATE_STABLE,
function_setup,
blockInfo_func,
- noop2,
blockinfo_func_finalizer,
block_func_merge,
dataBlockRequired,
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index aa5ce4fa57..e50c0daa4c 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -163,7 +163,7 @@ static void setResultOutputBuf(SQueryRuntimeEnv* pRuntimeEnv, SResultRow* pResul
int32_t numOfCols, int32_t* rowCellInfoOffset);
void setResultRowOutputBufInitCtx(SQueryRuntimeEnv *pRuntimeEnv, SResultRow *pResult, SQLFunctionCtx* pCtx, int32_t numOfOutput, int32_t* rowCellInfoOffset);
-static bool functionNeedToExecute(SQueryRuntimeEnv *pRuntimeEnv, SQLFunctionCtx *pCtx, int32_t functionId);
+static bool functionNeedToExecute(SQueryRuntimeEnv *pRuntimeEnv, SQLFunctionCtx *pCtx);
static void setBlockStatisInfo(SQLFunctionCtx *pCtx, SSDataBlock* pSDataBlock, SColIndex* pColIndex);
@@ -186,7 +186,7 @@ static int32_t getNumOfScanTimes(SQueryAttr* pQueryAttr);
static void destroyBasicOperatorInfo(void* param, int32_t numOfOutput);
static void destroySFillOperatorInfo(void* param, int32_t numOfOutput);
static void destroyGroupbyOperatorInfo(void* param, int32_t numOfOutput);
-static void destroyArithOperatorInfo(void* param, int32_t numOfOutput);
+static void destroyProjectOperatorInfo(void* param, int32_t numOfOutput);
static void destroyTagScanOperatorInfo(void* param, int32_t numOfOutput);
static void destroySWindowOperatorInfo(void* param, int32_t numOfOutput);
static void destroyStateWindowOperatorInfo(void* param, int32_t numOfOutput);
@@ -370,7 +370,7 @@ static bool isProjQuery(SQueryAttr *pQueryAttr) {
return true;
}
-static bool hasNullRv(SColIndex* pColIndex, SDataStatis *pStatis) {
+static bool hasNull(SColIndex* pColIndex, SDataStatis *pStatis) {
if (TSDB_COL_IS_TAG(pColIndex->flag) || TSDB_COL_IS_UD_COL(pColIndex->flag) || pColIndex->colId == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
return false;
}
@@ -769,12 +769,13 @@ static int32_t getNumOfRowsInTimeWindow(SQueryRuntimeEnv* pRuntimeEnv, SDataBloc
static void doApplyFunctions(SQueryRuntimeEnv* pRuntimeEnv, SQLFunctionCtx* pCtx, STimeWindow* pWin, int32_t offset,
int32_t forwardStep, TSKEY* tsCol, int32_t numOfTotal, int32_t numOfOutput) {
SQueryAttr *pQueryAttr = pRuntimeEnv->pQueryAttr;
- bool hasPrev = pCtx[0].preAggVals.isSet;
+ bool hasAggregates = pCtx[0].preAggVals.isSet;
for (int32_t k = 0; k < numOfOutput; ++k) {
- pCtx[k].size = forwardStep;
+ pCtx[k].size = forwardStep;
pCtx[k].startTs = pWin->skey;
+ // keep it temprarily
char* start = pCtx[k].pInput;
int32_t pos = (QUERY_IS_ASC_QUERY(pQueryAttr)) ? offset : offset - (forwardStep - 1);
@@ -786,20 +787,18 @@ static void doApplyFunctions(SQueryRuntimeEnv* pRuntimeEnv, SQLFunctionCtx* pCtx
pCtx[k].ptsList = &tsCol[pos];
}
- int32_t functionId = pCtx[k].functionId;
-
// not a whole block involved in query processing, statistics data can not be used
// NOTE: the original value of isSet have been changed here
if (pCtx[k].preAggVals.isSet && forwardStep < numOfTotal) {
pCtx[k].preAggVals.isSet = false;
}
- if (functionNeedToExecute(pRuntimeEnv, &pCtx[k], functionId)) {
- aAggs[functionId].xFunction(&pCtx[k]);
+ if (functionNeedToExecute(pRuntimeEnv, &pCtx[k])) {
+ aAggs[pCtx[k].functionId].xFunction(&pCtx[k]);
}
// restore it
- pCtx[k].preAggVals.isSet = hasPrev;
+ pCtx[k].preAggVals.isSet = hasAggregates;
pCtx[k].pInput = start;
}
}
@@ -908,9 +907,6 @@ static void setNotInterpoWindowKey(SQLFunctionCtx* pCtx, int32_t numOfOutput, in
}
}
-// window start key interpolation
-
-
static void saveDataBlockLastRow(SQueryRuntimeEnv* pRuntimeEnv, SDataBlockInfo* pDataBlockInfo, SArray* pDataBlock,
int32_t rowIndex) {
if (pDataBlock == NULL) {
@@ -977,7 +973,7 @@ void setInputDataBlock(SOperatorInfo* pOperator, SQLFunctionCtx* pCtx, SSDataBlo
doSetInputDataBlockInfo(pOperator, pCtx, pBlock, order);
}
} else {
- if (/*pCtx[0].pInput == NULL && */pBlock->pDataBlock != NULL) {
+ if (pBlock->pDataBlock != NULL) {
doSetInputDataBlock(pOperator, pCtx, pBlock, order);
} else {
doSetInputDataBlockInfo(pOperator, pCtx, pBlock, order);
@@ -1036,15 +1032,14 @@ static void doAggregateImpl(SOperatorInfo* pOperator, TSKEY startTs, SQLFunction
SQueryRuntimeEnv* pRuntimeEnv = pOperator->pRuntimeEnv;
for (int32_t k = 0; k < pOperator->numOfOutput; ++k) {
- int32_t functionId = pCtx[k].functionId;
- if (functionNeedToExecute(pRuntimeEnv, &pCtx[k], functionId)) {
+ if (functionNeedToExecute(pRuntimeEnv, &pCtx[k])) {
pCtx[k].startTs = startTs;// this can be set during create the struct
- aAggs[functionId].xFunction(&pCtx[k]);
+ aAggs[pCtx[k].functionId].xFunction(&pCtx[k]);
}
}
}
-static void arithmeticApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SQLFunctionCtx *pCtx, int32_t numOfOutput) {
+static void projectApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SQLFunctionCtx *pCtx, int32_t numOfOutput) {
SQueryAttr *pQueryAttr = pRuntimeEnv->pQueryAttr;
for (int32_t k = 0; k < numOfOutput; ++k) {
@@ -1348,6 +1343,12 @@ static void doHashGroupbyAgg(SOperatorInfo* pOperator, SGroupbyOperatorInfo *pIn
return;
}
+ SColumnInfoData* pFirstColData = taosArrayGet(pSDataBlock->pDataBlock, 0);
+ int64_t* tsList = (pFirstColData->info.type == TSDB_DATA_TYPE_TIMESTAMP)? (int64_t*) pFirstColData->pData:NULL;
+
+ STimeWindow w = TSWINDOW_INITIALIZER;
+
+ int32_t num = 0;
for (int32_t j = 0; j < pSDataBlock->info.rows; ++j) {
char* val = ((char*)pColInfoData->pData) + bytes * j;
if (isNull(val, type)) {
@@ -1355,33 +1356,56 @@ static void doHashGroupbyAgg(SOperatorInfo* pOperator, SGroupbyOperatorInfo *pIn
}
// Compare with the previous row of this column, and do not set the output buffer again if they are identical.
- if (pInfo->prevData == NULL || (memcmp(pInfo->prevData, val, bytes) != 0)) {
- if (pInfo->prevData == NULL) {
- pInfo->prevData = malloc(bytes);
- }
-
+ if (pInfo->prevData == NULL) {
+ pInfo->prevData = malloc(bytes);
memcpy(pInfo->prevData, val, bytes);
+ num++;
+ continue;
+ }
- if (pQueryAttr->stableQuery && pQueryAttr->stabledev && (pRuntimeEnv->prevResult != NULL)) {
- setParamForStableStddevByColData(pRuntimeEnv, pInfo->binfo.pCtx, pOperator->numOfOutput, pOperator->pExpr, val, bytes);
+ if (IS_VAR_DATA_TYPE(type)) {
+ int32_t len = varDataLen(val);
+ if(len == varDataLen(pInfo->prevData) && memcmp(varDataVal(pInfo->prevData), varDataVal(val), len) == 0) {
+ num++;
+ continue;
}
-
- int32_t ret =
- setGroupResultOutputBuf(pRuntimeEnv, &(pInfo->binfo), pOperator->numOfOutput, val, type, bytes, item->groupIndex);
- if (ret != TSDB_CODE_SUCCESS) { // null data, too many state code
- longjmp(pRuntimeEnv->env, TSDB_CODE_QRY_APP_ERROR);
+ } else {
+ if (memcmp(pInfo->prevData, val, bytes) == 0) {
+ num++;
+ continue;
}
}
-
- // todo opt perf
- for (int32_t k = 0; k < pOperator->numOfOutput; ++k) {
- pInfo->binfo.pCtx[k].size = 1;
- int32_t functionId = pInfo->binfo.pCtx[k].functionId;
- if (functionNeedToExecute(pRuntimeEnv, &pInfo->binfo.pCtx[k], functionId)) {
- aAggs[functionId].xFunctionF(&pInfo->binfo.pCtx[k], j);
- }
+ if (pQueryAttr->stableQuery && pQueryAttr->stabledev && (pRuntimeEnv->prevResult != NULL)) {
+ setParamForStableStddevByColData(pRuntimeEnv, pInfo->binfo.pCtx, pOperator->numOfOutput, pOperator->pExpr, pInfo->prevData, bytes);
}
+
+ int32_t ret = setGroupResultOutputBuf(pRuntimeEnv, &(pInfo->binfo), pOperator->numOfOutput, pInfo->prevData, type, bytes, item->groupIndex);
+ if (ret != TSDB_CODE_SUCCESS) { // null data, too many state code
+ longjmp(pRuntimeEnv->env, TSDB_CODE_QRY_APP_ERROR);
+ }
+
+ doApplyFunctions(pRuntimeEnv, pInfo->binfo.pCtx, &w, j - num, num, tsList, pSDataBlock->info.rows, pOperator->numOfOutput);
+
+ num = 1;
+ memcpy(pInfo->prevData, val, bytes);
+ }
+
+ if (num > 0) {
+ char* val = ((char*)pColInfoData->pData) + bytes * (pSDataBlock->info.rows - num);
+ memcpy(pInfo->prevData, val, bytes);
+
+ if (pQueryAttr->stableQuery && pQueryAttr->stabledev && (pRuntimeEnv->prevResult != NULL)) {
+ setParamForStableStddevByColData(pRuntimeEnv, pInfo->binfo.pCtx, pOperator->numOfOutput, pOperator->pExpr, val, bytes);
+ }
+
+ int32_t ret = setGroupResultOutputBuf(pRuntimeEnv, &(pInfo->binfo), pOperator->numOfOutput, val, type, bytes, item->groupIndex);
+ if (ret != TSDB_CODE_SUCCESS) { // null data, too many state code
+ longjmp(pRuntimeEnv->env, TSDB_CODE_QRY_APP_ERROR);
+ }
+
+ doApplyFunctions(pRuntimeEnv, pInfo->binfo.pCtx, &w, pSDataBlock->info.rows - num, num, tsList, pSDataBlock->info.rows, pOperator->numOfOutput);
+ tfree(pInfo->prevData);
}
}
@@ -1455,9 +1479,7 @@ static void doSessionWindowAggImpl(SOperatorInfo* pOperator, SSWindowOperatorInf
}
static void setResultRowKey(SResultRow* pResultRow, char* pData, int16_t type) {
- int64_t v = -1;
- GET_TYPED_DATA(v, int64_t, type, pData);
- if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_NCHAR) {
+ if (IS_VAR_DATA_TYPE(type)) {
if (pResultRow->key == NULL) {
pResultRow->key = malloc(varDataTLen(pData));
varDataCopy(pResultRow->key, pData);
@@ -1465,6 +1487,9 @@ static void setResultRowKey(SResultRow* pResultRow, char* pData, int16_t type) {
assert(memcmp(pResultRow->key, pData, varDataTLen(pData)) == 0);
}
} else {
+ int64_t v = -1;
+ GET_TYPED_DATA(v, int64_t, type, pData);
+
pResultRow->win.skey = v;
pResultRow->win.ekey = v;
}
@@ -1480,7 +1505,7 @@ static int32_t setGroupResultOutputBuf(SQueryRuntimeEnv *pRuntimeEnv, SOptrBasic
// not assign result buffer yet, add new result buffer, TODO remove it
char* d = pData;
int16_t len = bytes;
- if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_NCHAR) {
+ if (IS_VAR_DATA_TYPE(type)) {
d = varDataVal(pData);
len = varDataLen(pData);
}
@@ -1522,11 +1547,12 @@ static int32_t getGroupbyColumnIndex(SGroupbyExpr *pGroupbyExpr, SSDataBlock* pD
return -1;
}
-static bool functionNeedToExecute(SQueryRuntimeEnv *pRuntimeEnv, SQLFunctionCtx *pCtx, int32_t functionId) {
+static bool functionNeedToExecute(SQueryRuntimeEnv *pRuntimeEnv, SQLFunctionCtx *pCtx) {
SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
SQueryAttr* pQueryAttr = pRuntimeEnv->pQueryAttr;
// in case of timestamp column, always generated results.
+ int32_t functionId = pCtx->functionId;
if (functionId == TSDB_FUNC_TS) {
return true;
}
@@ -1566,7 +1592,7 @@ void setBlockStatisInfo(SQLFunctionCtx *pCtx, SSDataBlock* pSDataBlock, SColInde
pCtx->preAggVals.isSet = false;
}
- pCtx->hasNull = hasNullRv(pColIndex, pStatis);
+ pCtx->hasNull = hasNull(pColIndex, pStatis);
// set the statistics data for primary time stamp column
if (pCtx->functionId == TSDB_FUNC_SPREAD && pColIndex->colId == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
@@ -1835,17 +1861,17 @@ static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, int32_t numOf
break;
}
- case OP_Arithmetic: { // TODO refactor to remove arith operator.
+ case OP_Project: { // TODO refactor to remove arith operator.
SOperatorInfo* prev = pRuntimeEnv->proot;
if (i == 0) {
- pRuntimeEnv->proot = createArithOperatorInfo(pRuntimeEnv, prev, pQueryAttr->pExpr1, pQueryAttr->numOfOutput);
+ pRuntimeEnv->proot = createProjectOperatorInfo(pRuntimeEnv, prev, pQueryAttr->pExpr1, pQueryAttr->numOfOutput);
if (pRuntimeEnv->proot != NULL && prev->operatorType != OP_DummyInput && prev->operatorType != OP_Join) { // TODO refactor
setTableScanFilterOperatorInfo(prev->info, pRuntimeEnv->proot);
}
} else {
prev = pRuntimeEnv->proot;
assert(pQueryAttr->pExpr2 != NULL);
- pRuntimeEnv->proot = createArithOperatorInfo(pRuntimeEnv, prev, pQueryAttr->pExpr2, pQueryAttr->numOfExpr2);
+ pRuntimeEnv->proot = createProjectOperatorInfo(pRuntimeEnv, prev, pQueryAttr->pExpr2, pQueryAttr->numOfExpr2);
}
break;
}
@@ -3539,6 +3565,7 @@ int32_t setTimestampListJoinInfo(SQueryRuntimeEnv* pRuntimeEnv, tVariant* pTag,
return 0;
}
+// TODO refactor: this funciton should be merged with setparamForStableStddevColumnData function.
void setParamForStableStddev(SQueryRuntimeEnv* pRuntimeEnv, SQLFunctionCtx* pCtx, int32_t numOfOutput, SExprInfo* pExprInfo) {
SQueryAttr* pQueryAttr = pRuntimeEnv->pQueryAttr;
@@ -3819,6 +3846,103 @@ int32_t doFillTimeIntervalGapsInResults(SFillInfo* pFillInfo, SSDataBlock *pOutp
return pOutput->info.rows;
}
+void publishOperatorProfEvent(SOperatorInfo* operatorInfo, EQueryProfEventType eventType) {
+ SQueryProfEvent event;
+ event.eventType = eventType;
+ event.eventTime = taosGetTimestampUs();
+ event.operatorType = operatorInfo->operatorType;
+
+ SQInfo* qInfo = operatorInfo->pRuntimeEnv->qinfo;
+ if (qInfo->summary.queryProfEvents) {
+ taosArrayPush(qInfo->summary.queryProfEvents, &event);
+ }
+}
+
+void publishQueryAbortEvent(SQInfo* pQInfo, int32_t code) {
+ SQueryProfEvent event;
+ event.eventType = QUERY_PROF_QUERY_ABORT;
+ event.eventTime = taosGetTimestampUs();
+ event.abortCode = code;
+
+ if (pQInfo->summary.queryProfEvents) {
+ taosArrayPush(pQInfo->summary.queryProfEvents, &event);
+ }
+}
+
+typedef struct {
+ uint8_t operatorType;
+ int64_t beginTime;
+ int64_t endTime;
+ int64_t selfTime;
+ int64_t descendantsTime;
+} SOperatorStackItem;
+
+static void doOperatorExecProfOnce(SOperatorStackItem* item, SQueryProfEvent* event, SArray* opStack, SHashObj* profResults) {
+ item->endTime = event->eventTime;
+ item->selfTime = (item->endTime - item->beginTime) - (item->descendantsTime);
+
+ for (int32_t j = 0; j < taosArrayGetSize(opStack); ++j) {
+ SOperatorStackItem* ancestor = taosArrayGet(opStack, j);
+ ancestor->descendantsTime += item->selfTime;
+ }
+
+ uint8_t operatorType = item->operatorType;
+ SOperatorProfResult* result = taosHashGet(profResults, &operatorType, sizeof(operatorType));
+ if (result != NULL) {
+ result->sumRunTimes++;
+ result->sumSelfTime += item->selfTime;
+ } else {
+ SOperatorProfResult opResult;
+ opResult.operatorType = operatorType;
+ opResult.sumSelfTime = item->selfTime;
+ opResult.sumRunTimes = 1;
+ taosHashPut(profResults, &(operatorType), sizeof(operatorType),
+ &opResult, sizeof(opResult));
+ }
+}
+
+void calculateOperatorProfResults(SQInfo* pQInfo) {
+ if (pQInfo->summary.queryProfEvents == NULL) {
+ qDebug("query prof events array is null");
+ return;
+ }
+
+ if (pQInfo->summary.operatorProfResults == NULL) {
+ qDebug("operator prof results hash is null");
+ return;
+ }
+
+ SArray* opStack = taosArrayInit(32, sizeof(SOperatorStackItem));
+ if (opStack == NULL) {
+ return;
+ }
+
+ size_t size = taosArrayGetSize(pQInfo->summary.queryProfEvents);
+ SHashObj* profResults = pQInfo->summary.operatorProfResults;
+
+ for (int i = 0; i < size; ++i) {
+ SQueryProfEvent* event = taosArrayGet(pQInfo->summary.queryProfEvents, i);
+ if (event->eventType == QUERY_PROF_BEFORE_OPERATOR_EXEC) {
+ SOperatorStackItem opItem;
+ opItem.operatorType = event->operatorType;
+ opItem.beginTime = event->eventTime;
+ opItem.descendantsTime = 0;
+ taosArrayPush(opStack, &opItem);
+ } else if (event->eventType == QUERY_PROF_AFTER_OPERATOR_EXEC) {
+ SOperatorStackItem* item = taosArrayPop(opStack);
+ assert(item->operatorType == event->operatorType);
+ doOperatorExecProfOnce(item, event, opStack, profResults);
+ } else if (event->eventType == QUERY_PROF_QUERY_ABORT) {
+ SOperatorStackItem* item;
+ while ((item = taosArrayPop(opStack)) != NULL) {
+ doOperatorExecProfOnce(item, event, opStack, profResults);
+ }
+ }
+ }
+
+ taosArrayDestroy(opStack);
+}
+
void queryCostStatis(SQInfo *pQInfo) {
SQueryRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv;
SQueryCostInfo *pSummary = &pQInfo->summary;
@@ -3839,6 +3963,8 @@ void queryCostStatis(SQInfo *pQInfo) {
pSummary->numOfTimeWindows = 0;
}
+ calculateOperatorProfResults(pQInfo);
+
qDebug("QInfo:0x%"PRIx64" :cost summary: elapsed time:%"PRId64" us, first merge:%"PRId64" us, total blocks:%d, "
"load block statis:%d, load data block:%d, total rows:%"PRId64 ", check rows:%"PRId64,
pQInfo->qId, pSummary->elapsedTime, pSummary->firstStageMergeTime, pSummary->totalBlocks, pSummary->loadBlockStatis,
@@ -3846,6 +3972,15 @@ void queryCostStatis(SQInfo *pQInfo) {
qDebug("QInfo:0x%"PRIx64" :cost summary: winResPool size:%.2f Kb, numOfWin:%"PRId64", tableInfoSize:%.2f Kb, hashTable:%.2f Kb", pQInfo->qId, pSummary->winInfoSize/1024.0,
pSummary->numOfTimeWindows, pSummary->tableInfoSize/1024.0, pSummary->hashSize/1024.0);
+
+ if (pSummary->operatorProfResults) {
+ SOperatorProfResult* opRes = taosHashIterate(pSummary->operatorProfResults, NULL);
+ while (opRes != NULL) {
+ qDebug("QInfo:0x%" PRIx64 " :cost summary: operator : %d, exec times: %" PRId64 ", self time: %" PRId64,
+ pQInfo->qId, opRes->operatorType, opRes->sumRunTimes, opRes->sumSelfTime);
+ opRes = taosHashIterate(pSummary->operatorProfResults, opRes);
+ }
+ }
}
//static void updateOffsetVal(SQueryRuntimeEnv *pRuntimeEnv, SDataBlockInfo *pBlockInfo) {
@@ -4247,6 +4382,15 @@ int32_t doInitQInfo(SQInfo* pQInfo, STSBuf* pTsBuf, void* tsdb, void* sourceOptr
// create runtime environment
int32_t numOfTables = (int32_t)pQueryAttr->tableGroupInfo.numOfTables;
pQInfo->summary.tableInfoSize += (numOfTables * sizeof(STableQueryInfo));
+ pQInfo->summary.queryProfEvents = taosArrayInit(512, sizeof(SQueryProfEvent));
+ if (pQInfo->summary.queryProfEvents == NULL) {
+ qDebug("failed to allocate query prof events array");
+ }
+ pQInfo->summary.operatorProfResults =
+ taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_TINYINT), true, HASH_NO_LOCK);
+ if (pQInfo->summary.operatorProfResults == NULL) {
+ qDebug("failed to allocate operator prof results hash");
+ }
code = setupQueryRuntimeEnv(pRuntimeEnv, (int32_t) pQueryAttr->tableGroupInfo.numOfTables, pOperator, param);
if (code != TSDB_CODE_SUCCESS) {
@@ -4606,8 +4750,8 @@ void setTableScanFilterOperatorInfo(STableScanInfo* pTableScanInfo, SOperatorInf
pTableScanInfo->pResultRowInfo = &pInfo->resultRowInfo;
pTableScanInfo->rowCellInfoOffset = pInfo->rowCellInfoOffset;
- } else if (pDownstream->operatorType == OP_Arithmetic) {
- SArithOperatorInfo *pInfo = pDownstream->info;
+ } else if (pDownstream->operatorType == OP_Project) {
+ SProjectOperatorInfo *pInfo = pDownstream->info;
pTableScanInfo->pCtx = pInfo->binfo.pCtx;
pTableScanInfo->pResultRowInfo = &pInfo->binfo.resultRowInfo;
@@ -4744,8 +4888,7 @@ SOperatorInfo* createGlobalAggregateOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv,
SMultiwayMergeInfo* pInfo = calloc(1, sizeof(SMultiwayMergeInfo));
pInfo->resultRowFactor =
- (int32_t)(GET_ROW_PARAM_FOR_MULTIOUTPUT(pRuntimeEnv->pQueryAttr, pRuntimeEnv->pQueryAttr->topBotQuery,
- false));
+ (int32_t)(GET_ROW_PARAM_FOR_MULTIOUTPUT(pRuntimeEnv->pQueryAttr, pRuntimeEnv->pQueryAttr->topBotQuery, false));
pRuntimeEnv->scanFlag = MERGE_STAGE; // TODO init when creating pCtx
@@ -4872,7 +5015,10 @@ static SSDataBlock* doAggregate(void* param, bool* newgroup) {
SOperatorInfo* upstream = pOperator->upstream[0];
while(1) {
+ publishOperatorProfEvent(upstream, QUERY_PROF_BEFORE_OPERATOR_EXEC);
SSDataBlock* pBlock = upstream->exec(upstream, newgroup);
+ publishOperatorProfEvent(upstream, QUERY_PROF_AFTER_OPERATOR_EXEC);
+
if (pBlock == NULL) {
break;
}
@@ -4927,7 +5073,10 @@ static SSDataBlock* doSTableAggregate(void* param, bool* newgroup) {
SOperatorInfo* upstream = pOperator->upstream[0];
while(1) {
+ publishOperatorProfEvent(upstream, QUERY_PROF_BEFORE_OPERATOR_EXEC);
SSDataBlock* pBlock = upstream->exec(upstream, newgroup);
+ publishOperatorProfEvent(upstream, QUERY_PROF_AFTER_OPERATOR_EXEC);
+
if (pBlock == NULL) {
break;
}
@@ -4963,23 +5112,23 @@ static SSDataBlock* doSTableAggregate(void* param, bool* newgroup) {
return pInfo->pRes;
}
-static SSDataBlock* doArithmeticOperation(void* param, bool* newgroup) {
+static SSDataBlock* doProjectOperation(void* param, bool* newgroup) {
SOperatorInfo* pOperator = (SOperatorInfo*) param;
- SArithOperatorInfo* pArithInfo = pOperator->info;
+ SProjectOperatorInfo* pProjectInfo = pOperator->info;
SQueryRuntimeEnv* pRuntimeEnv = pOperator->pRuntimeEnv;
- SOptrBasicInfo *pInfo = &pArithInfo->binfo;
+ SOptrBasicInfo *pInfo = &pProjectInfo->binfo;
SSDataBlock* pRes = pInfo->pRes;
int32_t order = pRuntimeEnv->pQueryAttr->order.order;
pRes->info.rows = 0;
- if (pArithInfo->existDataBlock) { // TODO refactor
+ if (pProjectInfo->existDataBlock) { // TODO refactor
STableQueryInfo* pTableQueryInfo = pRuntimeEnv->current;
- SSDataBlock* pBlock = pArithInfo->existDataBlock;
- pArithInfo->existDataBlock = NULL;
+ SSDataBlock* pBlock = pProjectInfo->existDataBlock;
+ pProjectInfo->existDataBlock = NULL;
*newgroup = true;
// todo dynamic set tags
@@ -4989,9 +5138,9 @@ static SSDataBlock* doArithmeticOperation(void* param, bool* newgroup) {
// the pDataBlock are always the same one, no need to call this again
setInputDataBlock(pOperator, pInfo->pCtx, pBlock, order);
- updateOutputBuf(&pArithInfo->binfo, &pArithInfo->bufCapacity, pBlock->info.rows);
+ updateOutputBuf(&pProjectInfo->binfo, &pProjectInfo->bufCapacity, pBlock->info.rows);
- arithmeticApplyFunctions(pRuntimeEnv, pInfo->pCtx, pOperator->numOfOutput);
+ projectApplyFunctions(pRuntimeEnv, pInfo->pCtx, pOperator->numOfOutput);
if (pTableQueryInfo != NULL) {
updateTableIdInfo(pTableQueryInfo, pBlock, pRuntimeEnv->pTableRetrieveTsMap, order);
}
@@ -5007,7 +5156,10 @@ static SSDataBlock* doArithmeticOperation(void* param, bool* newgroup) {
bool prevVal = *newgroup;
// The upstream exec may change the value of the newgroup, so use a local variable instead.
+ publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_BEFORE_OPERATOR_EXEC);
SSDataBlock* pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
+ publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_AFTER_OPERATOR_EXEC);
+
if (pBlock == NULL) {
assert(*newgroup == false);
@@ -5019,7 +5171,7 @@ static SSDataBlock* doArithmeticOperation(void* param, bool* newgroup) {
// Return result of the previous group in the firstly.
if (*newgroup) {
if (pRes->info.rows > 0) {
- pArithInfo->existDataBlock = pBlock;
+ pProjectInfo->existDataBlock = pBlock;
clearNumOfRes(pInfo->pCtx, pOperator->numOfOutput);
return pInfo->pRes;
} else { // init output buffer for a new group data
@@ -5039,9 +5191,9 @@ static SSDataBlock* doArithmeticOperation(void* param, bool* newgroup) {
// the pDataBlock are always the same one, no need to call this again
setInputDataBlock(pOperator, pInfo->pCtx, pBlock, order);
- updateOutputBuf(&pArithInfo->binfo, &pArithInfo->bufCapacity, pBlock->info.rows);
+ updateOutputBuf(&pProjectInfo->binfo, &pProjectInfo->bufCapacity, pBlock->info.rows);
- arithmeticApplyFunctions(pRuntimeEnv, pInfo->pCtx, pOperator->numOfOutput);
+ projectApplyFunctions(pRuntimeEnv, pInfo->pCtx, pOperator->numOfOutput);
if (pTableQueryInfo != NULL) {
updateTableIdInfo(pTableQueryInfo, pBlock, pRuntimeEnv->pTableRetrieveTsMap, order);
}
@@ -5067,7 +5219,10 @@ static SSDataBlock* doLimit(void* param, bool* newgroup) {
SSDataBlock* pBlock = NULL;
while (1) {
+ publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_BEFORE_OPERATOR_EXEC);
pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
+ publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_AFTER_OPERATOR_EXEC);
+
if (pBlock == NULL) {
setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
pOperator->status = OP_EXEC_DONE;
@@ -5117,7 +5272,10 @@ static SSDataBlock* doFilter(void* param, bool* newgroup) {
SQueryRuntimeEnv* pRuntimeEnv = pOperator->pRuntimeEnv;
while (1) {
+ publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_BEFORE_OPERATOR_EXEC);
SSDataBlock *pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
+ publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_AFTER_OPERATOR_EXEC);
+
if (pBlock == NULL) {
break;
}
@@ -5162,7 +5320,10 @@ static SSDataBlock* doIntervalAgg(void* param, bool* newgroup) {
SOperatorInfo* upstream = pOperator->upstream[0];
while(1) {
+ publishOperatorProfEvent(upstream, QUERY_PROF_BEFORE_OPERATOR_EXEC);
SSDataBlock* pBlock = upstream->exec(upstream, newgroup);
+ publishOperatorProfEvent(upstream, QUERY_PROF_AFTER_OPERATOR_EXEC);
+
if (pBlock == NULL) {
break;
}
@@ -5215,7 +5376,10 @@ static SSDataBlock* doSTableIntervalAgg(void* param, bool* newgroup) {
SOperatorInfo* upstream = pOperator->upstream[0];
while(1) {
+ publishOperatorProfEvent(upstream, QUERY_PROF_BEFORE_OPERATOR_EXEC);
SSDataBlock* pBlock = upstream->exec(upstream, newgroup);
+ publishOperatorProfEvent(upstream, QUERY_PROF_AFTER_OPERATOR_EXEC);
+
if (pBlock == NULL) {
break;
}
@@ -5317,6 +5481,7 @@ static void doStateWindowAggImpl(SOperatorInfo* pOperator, SStateWindowOperatorI
doApplyFunctions(pRuntimeEnv, pBInfo->pCtx, &pInfo->curWindow, pInfo->start, pInfo->numOfRows, tsList,
pSDataBlock->info.rows, pOperator->numOfOutput);
}
+
static SSDataBlock* doStateWindowAgg(void *param, bool* newgroup) {
SOperatorInfo* pOperator = (SOperatorInfo*) param;
if (pOperator->status == OP_EXEC_DONE) {
@@ -5342,7 +5507,10 @@ static SSDataBlock* doStateWindowAgg(void *param, bool* newgroup) {
STimeWindow win = pQueryAttr->window;
SOperatorInfo* upstream = pOperator->upstream[0];
while (1) {
+ publishOperatorProfEvent(upstream, QUERY_PROF_BEFORE_OPERATOR_EXEC);
SSDataBlock* pBlock = upstream->exec(upstream, newgroup);
+ publishOperatorProfEvent(upstream, QUERY_PROF_AFTER_OPERATOR_EXEC);
+
if (pBlock == NULL) {
break;
}
@@ -5400,7 +5568,9 @@ static SSDataBlock* doSessionWindowAgg(void* param, bool* newgroup) {
SOperatorInfo* upstream = pOperator->upstream[0];
while(1) {
+ publishOperatorProfEvent(upstream, QUERY_PROF_BEFORE_OPERATOR_EXEC);
SSDataBlock* pBlock = upstream->exec(upstream, newgroup);
+ publishOperatorProfEvent(upstream, QUERY_PROF_AFTER_OPERATOR_EXEC);
if (pBlock == NULL) {
break;
}
@@ -5451,7 +5621,9 @@ static SSDataBlock* hashGroupbyAggregate(void* param, bool* newgroup) {
SOperatorInfo* upstream = pOperator->upstream[0];
while(1) {
+ publishOperatorProfEvent(upstream, QUERY_PROF_BEFORE_OPERATOR_EXEC);
SSDataBlock* pBlock = upstream->exec(upstream, newgroup);
+ publishOperatorProfEvent(upstream, QUERY_PROF_AFTER_OPERATOR_EXEC);
if (pBlock == NULL) {
break;
}
@@ -5520,7 +5692,10 @@ static SSDataBlock* doFill(void* param, bool* newgroup) {
}
while(1) {
+ publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_BEFORE_OPERATOR_EXEC);
SSDataBlock* pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
+ publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_AFTER_OPERATOR_EXEC);
+
if (*newgroup) {
assert(pBlock != NULL);
}
@@ -5680,8 +5855,8 @@ static void destroyGroupbyOperatorInfo(void* param, int32_t numOfOutput) {
tfree(pInfo->prevData);
}
-static void destroyArithOperatorInfo(void* param, int32_t numOfOutput) {
- SArithOperatorInfo* pInfo = (SArithOperatorInfo*) param;
+static void destroyProjectOperatorInfo(void* param, int32_t numOfOutput) {
+ SProjectOperatorInfo* pInfo = (SProjectOperatorInfo*) param;
doDestroyBasicInfo(&pInfo->binfo, numOfOutput);
}
@@ -5727,8 +5902,8 @@ SOperatorInfo* createMultiTableAggOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SO
return pOperator;
}
-SOperatorInfo* createArithOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput) {
- SArithOperatorInfo* pInfo = calloc(1, sizeof(SArithOperatorInfo));
+SOperatorInfo* createProjectOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput) {
+ SProjectOperatorInfo* pInfo = calloc(1, sizeof(SProjectOperatorInfo));
pInfo->seed = rand();
pInfo->bufCapacity = pRuntimeEnv->resultInfo.capacity;
@@ -5741,8 +5916,8 @@ SOperatorInfo* createArithOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorI
setDefaultOutputBuf(pRuntimeEnv, pBInfo, pInfo->seed, MASTER_SCAN);
SOperatorInfo* pOperator = calloc(1, sizeof(SOperatorInfo));
- pOperator->name = "ArithmeticOperator";
- pOperator->operatorType = OP_Arithmetic;
+ pOperator->name = "ProjectOperator";
+ pOperator->operatorType = OP_Project;
pOperator->blockingOptr = false;
pOperator->status = OP_IN_EXECUTING;
pOperator->info = pInfo;
@@ -5750,8 +5925,8 @@ SOperatorInfo* createArithOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorI
pOperator->numOfOutput = numOfOutput;
pOperator->pRuntimeEnv = pRuntimeEnv;
- pOperator->exec = doArithmeticOperation;
- pOperator->cleanup = destroyArithOperatorInfo;
+ pOperator->exec = doProjectOperation;
+ pOperator->cleanup = destroyProjectOperatorInfo;
appendUpstream(pOperator, upstream);
return pOperator;
@@ -6190,7 +6365,10 @@ static SSDataBlock* hashDistinct(void* param, bool* newgroup) {
pRes->info.rows = 0;
SSDataBlock* pBlock = NULL;
while(1) {
+ publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_BEFORE_OPERATOR_EXEC);
pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
+ publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_AFTER_OPERATOR_EXEC);
+
if (pBlock == NULL) {
setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
pOperator->status = OP_EXEC_DONE;
@@ -6332,7 +6510,7 @@ static bool validateQueryMsg(SQueryTableMsg *pQueryMsg) {
return true;
}
-static UNUSED_FUNC bool validateQueryTableCols(SQueriedTableInfo* pTableInfo, SSqlExpr** pExpr, int32_t numOfOutput,
+static bool validateQueryTableCols(SQueriedTableInfo* pTableInfo, SSqlExpr** pExpr, int32_t numOfOutput,
SColumnInfo* pTagCols, void* pMsg) {
int32_t numOfTotal = pTableInfo->numOfCols + pTableInfo->numOfTags;
if (pTableInfo->numOfCols < 0 || pTableInfo->numOfTags < 0 || numOfTotal > TSDB_MAX_COLUMNS) {
@@ -6517,6 +6695,7 @@ int32_t convertQueryMsg(SQueryTableMsg *pQueryMsg, SQueryParam* param) {
pExprMsg->resType = htons(pExprMsg->resType);
pExprMsg->resBytes = htons(pExprMsg->resBytes);
+ pExprMsg->interBytes = htonl(pExprMsg->interBytes);
pExprMsg->functionId = htons(pExprMsg->functionId);
pExprMsg->numOfParams = htons(pExprMsg->numOfParams);
@@ -6724,41 +6903,41 @@ _cleanup:
return code;
}
- int32_t cloneExprFilterInfo(SColumnFilterInfo **dst, SColumnFilterInfo* src, int32_t filterNum) {
- if (filterNum <= 0) {
- return TSDB_CODE_SUCCESS;
- }
-
- *dst = calloc(filterNum, sizeof(*src));
- if (*dst == NULL) {
- return TSDB_CODE_QRY_OUT_OF_MEMORY;
- }
-
- memcpy(*dst, src, sizeof(*src) * filterNum);
-
- for (int32_t i = 0; i < filterNum; i++) {
- if ((*dst)[i].filterstr && dst[i]->len > 0) {
- void *pz = calloc(1, (size_t)(*dst)[i].len + 1);
-
- if (pz == NULL) {
- if (i == 0) {
- free(*dst);
- } else {
- freeColumnFilterInfo(*dst, i);
- }
-
- return TSDB_CODE_QRY_OUT_OF_MEMORY;
- }
-
- memcpy(pz, (void *)src->pz, (size_t)src->len + 1);
-
- (*dst)[i].pz = (int64_t)pz;
- }
- }
-
+int32_t cloneExprFilterInfo(SColumnFilterInfo **dst, SColumnFilterInfo* src, int32_t filterNum) {
+ if (filterNum <= 0) {
return TSDB_CODE_SUCCESS;
}
+ *dst = calloc(filterNum, sizeof(*src));
+ if (*dst == NULL) {
+ return TSDB_CODE_QRY_OUT_OF_MEMORY;
+ }
+
+ memcpy(*dst, src, sizeof(*src) * filterNum);
+
+ for (int32_t i = 0; i < filterNum; i++) {
+ if ((*dst)[i].filterstr && dst[i]->len > 0) {
+ void *pz = calloc(1, (size_t)(*dst)[i].len + 1);
+
+ if (pz == NULL) {
+ if (i == 0) {
+ free(*dst);
+ } else {
+ freeColumnFilterInfo(*dst, i);
+ }
+
+ return TSDB_CODE_QRY_OUT_OF_MEMORY;
+ }
+
+ memcpy(pz, (void *)src->pz, (size_t)src->len + 1);
+
+ (*dst)[i].pz = (int64_t)pz;
+ }
+ }
+
+ return TSDB_CODE_SUCCESS;
+}
+
int32_t buildArithmeticExprFromMsg(SExprInfo *pExprInfo, void *pQueryMsg) {
qDebug("qmsg:%p create arithmetic expr from binary", pQueryMsg);
@@ -6817,8 +6996,8 @@ int32_t createQueryFunc(SQueriedTableInfo* pTableInfo, int32_t numOfOutput, SExp
for (int32_t i = 0; i < numOfOutput; ++i) {
pExprs[i].base = *pExprMsg[i];
- memset(pExprs[i].base.param, 0, sizeof(tVariant) * tListLen(pExprs[i].base.param));
+ memset(pExprs[i].base.param, 0, sizeof(tVariant) * tListLen(pExprs[i].base.param));
for (int32_t j = 0; j < pExprMsg[i]->numOfParams; ++j) {
tVariantAssign(&pExprs[i].base.param[j], &pExprMsg[i]->param[j]);
}
@@ -6893,6 +7072,7 @@ int32_t createQueryFunc(SQueriedTableInfo* pTableInfo, int32_t numOfOutput, SExp
return TSDB_CODE_QRY_INVALID_MSG;
}
+ // todo remove it
if (getResultDataInfo(type, bytes, pExprs[i].base.functionId, param, &pExprs[i].base.resType, &pExprs[i].base.resBytes,
&pExprs[i].base.interBytes, 0, isSuperTable) != TSDB_CODE_SUCCESS) {
tfree(pExprs);
@@ -7074,6 +7254,8 @@ int32_t createFilterInfo(SQueryAttr* pQueryAttr, uint64_t qId) {
doCreateFilterInfo(pQueryAttr->tableCols, pQueryAttr->numOfCols, pQueryAttr->numOfFilterCols,
&pQueryAttr->pFilterInfo, qId);
+ pQueryAttr->createFilterOperator = true;
+
return TSDB_CODE_SUCCESS;
}
@@ -7359,11 +7541,16 @@ int32_t initQInfo(STsBufInfo* pTsBufInfo, void* tsdb, void* sourceOptr, SQInfo*
SQueryAttr *pQueryAttr = pRuntimeEnv->pQueryAttr;
STSBuf *pTsBuf = NULL;
- if (pTsBufInfo->tsLen > 0) { // open new file to save the result
- char *tsBlock = start + pTsBufInfo->tsOffset;
- pTsBuf = tsBufCreateFromCompBlocks(tsBlock, pTsBufInfo->tsNumOfBlocks, pTsBufInfo->tsLen, pTsBufInfo->tsOrder,
- pQueryAttr->vgId);
+ if (pTsBufInfo->tsLen > 0) { // open new file to save the result
+ char* tsBlock = start + pTsBufInfo->tsOffset;
+ pTsBuf = tsBufCreateFromCompBlocks(tsBlock, pTsBufInfo->tsNumOfBlocks, pTsBufInfo->tsLen, pTsBufInfo->tsOrder,
+ pQueryAttr->vgId);
+
+ if (pTsBuf == NULL) {
+ code = TSDB_CODE_QRY_NO_DISKSPACE;
+ goto _error;
+ }
tsBufResetPos(pTsBuf);
bool ret = tsBufNextPos(pTsBuf);
UNUSED(ret);
@@ -7507,6 +7694,9 @@ void freeQInfo(SQInfo *pQInfo) {
tfree(pQInfo->pBuf);
tfree(pQInfo->sql);
+ taosArrayDestroy(pQInfo->summary.queryProfEvents);
+ taosHashCleanup(pQInfo->summary.operatorProfResults);
+
taosArrayDestroy(pRuntimeEnv->groupResInfo.pRows);
pQInfo->signature = 0;
diff --git a/src/query/src/qPlan.c b/src/query/src/qPlan.c
index ee587a515d..9c06a87b81 100644
--- a/src/query/src/qPlan.c
+++ b/src/query/src/qPlan.c
@@ -565,7 +565,7 @@ SArray* createExecOperatorPlan(SQueryAttr* pQueryAttr) {
taosArrayPush(plan, &op);
if (pQueryAttr->pExpr2 != NULL) {
- op = OP_Arithmetic;
+ op = OP_Project;
taosArrayPush(plan, &op);
}
@@ -585,7 +585,7 @@ SArray* createExecOperatorPlan(SQueryAttr* pQueryAttr) {
}
if (pQueryAttr->pExpr2 != NULL) {
- op = OP_Arithmetic;
+ op = OP_Project;
taosArrayPush(plan, &op);
}
} else if (pQueryAttr->sw.gap > 0) {
@@ -593,7 +593,7 @@ SArray* createExecOperatorPlan(SQueryAttr* pQueryAttr) {
taosArrayPush(plan, &op);
if (pQueryAttr->pExpr2 != NULL) {
- op = OP_Arithmetic;
+ op = OP_Project;
taosArrayPush(plan, &op);
}
} else if (pQueryAttr->stateWindow) {
@@ -601,7 +601,7 @@ SArray* createExecOperatorPlan(SQueryAttr* pQueryAttr) {
taosArrayPush(plan, &op);
if (pQueryAttr->pExpr2 != NULL) {
- op = OP_Arithmetic;
+ op = OP_Project;
taosArrayPush(plan, &op);
}
} else if (pQueryAttr->simpleAgg) {
@@ -619,15 +619,15 @@ SArray* createExecOperatorPlan(SQueryAttr* pQueryAttr) {
}
if (pQueryAttr->pExpr2 != NULL && !pQueryAttr->stableQuery) {
- op = OP_Arithmetic;
+ op = OP_Project;
taosArrayPush(plan, &op);
}
} else { // diff/add/multiply/subtract/division
- if (pQueryAttr->numOfFilterCols > 0 && pQueryAttr->vgId == 0) { // todo refactor
+ if (pQueryAttr->numOfFilterCols > 0 && pQueryAttr->createFilterOperator && pQueryAttr->vgId == 0) { // todo refactor
op = OP_Filter;
taosArrayPush(plan, &op);
} else {
- op = OP_Arithmetic;
+ op = OP_Project;
taosArrayPush(plan, &op);
}
}
@@ -665,7 +665,7 @@ SArray* createGlobalMergePlan(SQueryAttr* pQueryAttr) {
}
if (pQueryAttr->pExpr2 != NULL) {
- op = OP_Arithmetic;
+ op = OP_Project;
taosArrayPush(plan, &op);
}
}
diff --git a/src/query/src/qTsbuf.c b/src/query/src/qTsbuf.c
index cf67e37cf2..27c877fafa 100644
--- a/src/query/src/qTsbuf.c
+++ b/src/query/src/qTsbuf.c
@@ -2,6 +2,7 @@
#include "taoserror.h"
#include "tscompression.h"
#include "tutil.h"
+#include "queryLog.h"
static int32_t getDataStartOffset();
static void TSBufUpdateGroupInfo(STSBuf* pTSBuf, int32_t index, STSGroupBlockInfo* pBlockInfo);
@@ -633,10 +634,15 @@ int32_t STSBufUpdateHeader(STSBuf* pTSBuf, STSBufFileHeader* pHeader) {
int32_t r = fseek(pTSBuf->f, 0, SEEK_SET);
if (r != 0) {
+ qError("fseek failed, errno:%d", errno);
+ return -1;
+ }
+
+ size_t ws = fwrite(pHeader, sizeof(STSBufFileHeader), 1, pTSBuf->f);
+ if (ws != 1) {
+ qError("ts update header fwrite failed, size:%d, expected size:%d", (int32_t)ws, (int32_t)sizeof(STSBufFileHeader));
return -1;
}
-
- fwrite(pHeader, sizeof(STSBufFileHeader), 1, pTSBuf->f);
return 0;
}
@@ -853,9 +859,17 @@ STSBuf* tsBufCreateFromCompBlocks(const char* pData, int32_t numOfBlocks, int32_
TSBufUpdateGroupInfo(pTSBuf, pTSBuf->numOfGroups - 1, pBlockInfo);
int32_t ret = fseek(pTSBuf->f, pBlockInfo->offset, SEEK_SET);
- UNUSED(ret);
+ if (ret == -1) {
+ qError("fseek failed, errno:%d", errno);
+ tsBufDestroy(pTSBuf);
+ return NULL;
+ }
size_t sz = fwrite((void*)pData, 1, len, pTSBuf->f);
- UNUSED(sz);
+ if (sz != len) {
+ qError("ts data fwrite failed, write size:%d, expected size:%d", (int32_t)sz, len);
+ tsBufDestroy(pTSBuf);
+ return NULL;
+ }
pTSBuf->fileSize += len;
pTSBuf->tsOrder = order;
@@ -863,9 +877,16 @@ STSBuf* tsBufCreateFromCompBlocks(const char* pData, int32_t numOfBlocks, int32_
STSBufFileHeader header = {
.magic = TS_COMP_FILE_MAGIC, .numOfGroup = pTSBuf->numOfGroups, .tsOrder = pTSBuf->tsOrder};
- STSBufUpdateHeader(pTSBuf, &header);
+ if (STSBufUpdateHeader(pTSBuf, &header) < 0) {
+ tsBufDestroy(pTSBuf);
+ return NULL;
+ }
- taosFsync(fileno(pTSBuf->f));
+ if (taosFsync(fileno(pTSBuf->f)) == -1) {
+ qError("fsync failed, errno:%d", errno);
+ tsBufDestroy(pTSBuf);
+ return NULL;
+ }
return pTSBuf;
}
diff --git a/src/query/src/queryMain.c b/src/query/src/queryMain.c
index 38ef81e793..787cb2f7d1 100644
--- a/src/query/src/queryMain.c
+++ b/src/query/src/queryMain.c
@@ -232,6 +232,7 @@ bool qTableQuery(qinfo_t qinfo, uint64_t *qId) {
// error occurs, record the error code and return to client
int32_t ret = setjmp(pQInfo->runtimeEnv.env);
if (ret != TSDB_CODE_SUCCESS) {
+ publishQueryAbortEvent(pQInfo, ret);
pQInfo->code = ret;
qDebug("QInfo:0x%"PRIx64" query abort due to error/cancel occurs, code:%s", pQInfo->qId, tstrerror(pQInfo->code));
return doBuildResCheck(pQInfo);
@@ -240,7 +241,9 @@ bool qTableQuery(qinfo_t qinfo, uint64_t *qId) {
qDebug("QInfo:0x%"PRIx64" query task is launched", pQInfo->qId);
bool newgroup = false;
+ publishOperatorProfEvent(pRuntimeEnv->proot, QUERY_PROF_BEFORE_OPERATOR_EXEC);
pRuntimeEnv->outputBuf = pRuntimeEnv->proot->exec(pRuntimeEnv->proot, &newgroup);
+ publishOperatorProfEvent(pRuntimeEnv->proot, QUERY_PROF_AFTER_OPERATOR_EXEC);
pRuntimeEnv->resultInfo.total += GET_NUM_OF_RESULTS(pRuntimeEnv);
if (isQueryKilled(pQInfo)) {
diff --git a/src/query/tests/astTest.cpp b/src/query/tests/astTest.cpp
index ce7b2f94a1..1143d00e8d 100644
--- a/src/query/tests/astTest.cpp
+++ b/src/query/tests/astTest.cpp
@@ -10,6 +10,7 @@
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wwrite-strings"
+#pragma GCC diagnostic ignored "-Wunused-function"
typedef struct ResultObj {
int32_t numOfResult;
diff --git a/src/query/tests/histogramTest.cpp b/src/query/tests/histogramTest.cpp
index 3088d6f807..0266ecffc1 100644
--- a/src/query/tests/histogramTest.cpp
+++ b/src/query/tests/histogramTest.cpp
@@ -5,6 +5,10 @@
#include "taos.h"
#include "qHistogram.h"
+
+#pragma GCC diagnostic ignored "-Wunused-function"
+#pragma GCC diagnostic ignored "-Wunused-variable"
+
namespace {
void doHistogramAddTest() {
SHistogramInfo* pHisto = NULL;
diff --git a/src/query/tests/patternMatchTest.cpp b/src/query/tests/patternMatchTest.cpp
index f3e0d3e119..091604c65c 100644
--- a/src/query/tests/patternMatchTest.cpp
+++ b/src/query/tests/patternMatchTest.cpp
@@ -6,6 +6,9 @@
#include "qAggMain.h"
#include "tcompare.h"
+#pragma GCC diagnostic ignored "-Wunused-function"
+#pragma GCC diagnostic ignored "-Wunused-variable"
+
TEST(testCase, patternMatchTest) {
SPatternCompareInfo info = PATTERN_COMPARE_INFO_INITIALIZER;
diff --git a/src/query/tests/percentileTest.cpp b/src/query/tests/percentileTest.cpp
index 104bfb3c06..1b6951201a 100644
--- a/src/query/tests/percentileTest.cpp
+++ b/src/query/tests/percentileTest.cpp
@@ -7,6 +7,9 @@
#include "qPercentile.h"
+#pragma GCC diagnostic ignored "-Wunused-function"
+#pragma GCC diagnostic ignored "-Wunused-variable"
+
namespace {
tMemBucket *createBigIntDataBucket(int32_t start, int32_t end) {
tMemBucket *pBucket = tMemBucketCreate(sizeof(int64_t), TSDB_DATA_TYPE_BIGINT, start, end);
diff --git a/src/query/tests/resultBufferTest.cpp b/src/query/tests/resultBufferTest.cpp
index 491d75ccb9..54ac0bf4e5 100644
--- a/src/query/tests/resultBufferTest.cpp
+++ b/src/query/tests/resultBufferTest.cpp
@@ -6,6 +6,9 @@
#include "taos.h"
#include "tsdb.h"
+#pragma GCC diagnostic ignored "-Wunused-function"
+#pragma GCC diagnostic ignored "-Wunused-variable"
+
namespace {
// simple test
void simpleTest() {
diff --git a/src/query/tests/tsBufTest.cpp b/src/query/tests/tsBufTest.cpp
index dd7f03a494..04c5a15252 100644
--- a/src/query/tests/tsBufTest.cpp
+++ b/src/query/tests/tsBufTest.cpp
@@ -9,6 +9,10 @@
#include "ttoken.h"
#include "tutil.h"
+#pragma GCC diagnostic ignored "-Wunused-function"
+#pragma GCC diagnostic ignored "-Wunused-variable"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+
namespace {
/**
*
diff --git a/src/query/tests/unitTest.cpp b/src/query/tests/unitTest.cpp
index 33ba8200d3..e5487a061d 100644
--- a/src/query/tests/unitTest.cpp
+++ b/src/query/tests/unitTest.cpp
@@ -6,14 +6,17 @@
#include "taos.h"
#include "tsdb.h"
+#pragma GCC diagnostic ignored "-Wwrite-strings"
+#pragma GCC diagnostic ignored "-Wunused-function"
+#pragma GCC diagnostic ignored "-Wunused-variable"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#pragma GCC diagnostic ignored "-Wsign-compare"
+
#include "../../client/inc/tscUtil.h"
#include "tutil.h"
#include "tvariant.h"
#include "ttokendef.h"
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wwrite-strings"
-
namespace {
int32_t testValidateName(char* name) {
SStrToken token = {0};
diff --git a/src/tfs/src/tfs.c b/src/tfs/src/tfs.c
index f78535b8ed..9dc68dcdfd 100644
--- a/src/tfs/src/tfs.c
+++ b/src/tfs/src/tfs.c
@@ -480,11 +480,13 @@ static int tfsFormatDir(char *idir, char *odir) {
return -1;
}
- if (realpath(wep.we_wordv[0], odir) == NULL) {
+ char tmp[PATH_MAX] = {0};
+ if (realpath(wep.we_wordv[0], tmp) == NULL) {
terrno = TAOS_SYSTEM_ERROR(errno);
wordfree(&wep);
return -1;
}
+ strcpy(odir, tmp);
wordfree(&wep);
return 0;
diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index 92edd4d160..92a0d489b3 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -3364,7 +3364,7 @@ static bool tableFilterFp(const void* pNode, void* param) {
GET_TYPED_DATA(v, uint64_t, pInfo->sch.type, val);
return NULL != taosHashGet((SHashObj *)pInfo->q, (char *)&v, sizeof(v));
}
- else if (type == TSDB_DATA_TYPE_DOUBLE || type == TSDB_DATA_TYPE_DOUBLE) {
+ else if (type == TSDB_DATA_TYPE_DOUBLE || type == TSDB_DATA_TYPE_FLOAT) {
double v;
GET_TYPED_DATA(v, double, pInfo->sch.type, val);
return NULL != taosHashGet((SHashObj *)pInfo->q, (char *)&v, sizeof(v));
diff --git a/src/util/inc/tsched.h b/src/util/inc/tsched.h
index 3e481cbc32..a1591512c1 100644
--- a/src/util/inc/tsched.h
+++ b/src/util/inc/tsched.h
@@ -28,10 +28,41 @@ typedef struct SSchedMsg {
void *thandle;
} SSchedMsg;
-void *taosInitScheduler(int queueSize, int numOfThreads, const char *label);
-void *taosInitSchedulerWithInfo(int queueSize, int numOfThreads, const char *label, void *tmrCtrl);
-int taosScheduleTask(void *qhandle, SSchedMsg *pMsg);
-void taosCleanUpScheduler(void *param);
+/**
+ * Create a thread-safe ring-buffer based task queue and return the instance. A thread
+ * pool will be created to consume the messages in the queue.
+ * @param capacity the queue capacity
+ * @param numOfThreads the number of threads for the thread pool
+ * @param label the label of the queue
+ * @return the created queue scheduler
+ */
+void *taosInitScheduler(int capacity, int numOfThreads, const char *label);
+
+/**
+ * Create a thread-safe ring-buffer based task queue and return the instance.
+ * Same as taosInitScheduler, and it also print the queue status every 1 minite.
+ * @param capacity the queue capacity
+ * @param numOfThreads the number of threads for the thread pool
+ * @param label the label of the queue
+ * @param tmrCtrl the timer controller, tmr_ctrl_t*
+ * @return the created queue scheduler
+ */
+void *taosInitSchedulerWithInfo(int capacity, int numOfThreads, const char *label, void *tmrCtrl);
+
+/**
+ * Clean up the queue scheduler instance and free the memory.
+ * @param queueScheduler the queue scheduler to free
+ */
+void taosCleanUpScheduler(void *queueScheduler);
+
+/**
+ * Schedule a new task to run, the task is described by pMsg.
+ * The function may be blocked if no thread is available to execute the task.
+ * That may happen when all threads are busy.
+ * @param queueScheduler the queue scheduler instance
+ * @param pMsg the message for the task
+ */
+void taosScheduleTask(void *queueScheduler, SSchedMsg *pMsg);
#ifdef __cplusplus
}
diff --git a/src/util/src/tconfig.c b/src/util/src/tconfig.c
index c4bd577602..442e83bb4f 100644
--- a/src/util/src/tconfig.c
+++ b/src/util/src/tconfig.c
@@ -151,7 +151,7 @@ static bool taosReadDirectoryConfig(SGlobalCfg *cfg, char *input_value) {
wordfree(&full_path);
- char tmp[1025] = {0};
+ char tmp[PATH_MAX] = {0};
if (realpath(option, tmp) != NULL) {
strcpy(option, tmp);
}
diff --git a/src/util/src/tsched.c b/src/util/src/tsched.c
index f014dd0fab..16142470c9 100644
--- a/src/util/src/tsched.c
+++ b/src/util/src/tsched.c
@@ -108,39 +108,47 @@ void *taosInitScheduler(int queueSize, int numOfThreads, const char *label) {
void *taosInitSchedulerWithInfo(int queueSize, int numOfThreads, const char *label, void *tmrCtrl) {
SSchedQueue* pSched = taosInitScheduler(queueSize, numOfThreads, label);
-
+
if (tmrCtrl != NULL && pSched != NULL) {
pSched->pTmrCtrl = tmrCtrl;
taosTmrReset(taosDumpSchedulerStatus, DUMP_SCHEDULER_TIME_WINDOW, pSched, pSched->pTmrCtrl, &pSched->pTimer);
}
-
+
return pSched;
}
-void *taosProcessSchedQueue(void *param) {
+void *taosProcessSchedQueue(void *scheduler) {
SSchedMsg msg;
- SSchedQueue *pSched = (SSchedQueue *)param;
+ SSchedQueue *pSched = (SSchedQueue *)scheduler;
+ int ret = 0;
while (1) {
- if (tsem_wait(&pSched->fullSem) != 0) {
- uError("wait %s fullSem failed(%s)", pSched->label, strerror(errno));
+ if ((ret = tsem_wait(&pSched->fullSem)) != 0) {
+ uFatal("wait %s fullSem failed(%s)", pSched->label, strerror(errno));
+ exit(ret);
}
if (pSched->stop) {
break;
}
- if (pthread_mutex_lock(&pSched->queueMutex) != 0)
- uError("lock %s queueMutex failed(%s)", pSched->label, strerror(errno));
+ if ((ret = pthread_mutex_lock(&pSched->queueMutex)) != 0) {
+ uFatal("lock %s queueMutex failed(%s)", pSched->label, strerror(errno));
+ exit(ret);
+ }
msg = pSched->queue[pSched->fullSlot];
memset(pSched->queue + pSched->fullSlot, 0, sizeof(SSchedMsg));
pSched->fullSlot = (pSched->fullSlot + 1) % pSched->queueSize;
- if (pthread_mutex_unlock(&pSched->queueMutex) != 0)
- uError("unlock %s queueMutex failed(%s)", pSched->label, strerror(errno));
+ if ((ret = pthread_mutex_unlock(&pSched->queueMutex)) != 0) {
+ uFatal("unlock %s queueMutex failed(%s)", pSched->label, strerror(errno));
+ exit(ret);
+ }
- if (tsem_post(&pSched->emptySem) != 0)
- uError("post %s emptySem failed(%s)", pSched->label, strerror(errno));
+ if ((ret = tsem_post(&pSched->emptySem)) != 0) {
+ uFatal("post %s emptySem failed(%s)", pSched->label, strerror(errno));
+ exit(ret);
+ }
if (msg.fp)
(*(msg.fp))(&msg);
@@ -151,30 +159,37 @@ void *taosProcessSchedQueue(void *param) {
return NULL;
}
-int taosScheduleTask(void *qhandle, SSchedMsg *pMsg) {
- SSchedQueue *pSched = (SSchedQueue *)qhandle;
+void taosScheduleTask(void *queueScheduler, SSchedMsg *pMsg) {
+ SSchedQueue *pSched = (SSchedQueue *)queueScheduler;
+ int ret = 0;
+
if (pSched == NULL) {
uError("sched is not ready, msg:%p is dropped", pMsg);
- return 0;
+ return;
}
- if (tsem_wait(&pSched->emptySem) != 0) {
- uError("wait %s emptySem failed(%s)", pSched->label, strerror(errno));
+ if ((ret = tsem_wait(&pSched->emptySem)) != 0) {
+ uFatal("wait %s emptySem failed(%s)", pSched->label, strerror(errno));
+ exit(ret);
}
- if (pthread_mutex_lock(&pSched->queueMutex) != 0)
- uError("lock %s queueMutex failed(%s)", pSched->label, strerror(errno));
+ if ((ret = pthread_mutex_lock(&pSched->queueMutex)) != 0) {
+ uFatal("lock %s queueMutex failed(%s)", pSched->label, strerror(errno));
+ exit(ret);
+ }
pSched->queue[pSched->emptySlot] = *pMsg;
pSched->emptySlot = (pSched->emptySlot + 1) % pSched->queueSize;
- if (pthread_mutex_unlock(&pSched->queueMutex) != 0)
- uError("unlock %s queueMutex failed(%s)", pSched->label, strerror(errno));
+ if ((ret = pthread_mutex_unlock(&pSched->queueMutex)) != 0) {
+ uFatal("unlock %s queueMutex failed(%s)", pSched->label, strerror(errno));
+ exit(ret);
+ }
- if (tsem_post(&pSched->fullSem) != 0)
- uError("post %s fullSem failed(%s)", pSched->label, strerror(errno));
-
- return 0;
+ if ((ret = tsem_post(&pSched->fullSem)) != 0) {
+ uFatal("post %s fullSem failed(%s)", pSched->label, strerror(errno));
+ exit(ret);
+ }
}
void taosCleanUpScheduler(void *param) {
@@ -219,4 +234,4 @@ void taosDumpSchedulerStatus(void *qhandle, void *tmrId) {
}
taosTmrReset(taosDumpSchedulerStatus, DUMP_SCHEDULER_TIME_WINDOW, pSched, pSched->pTmrCtrl, &pSched->pTimer);
-}
+}
\ No newline at end of file
diff --git a/tests/pytest/fulltest.sh b/tests/pytest/fulltest.sh
index ed298a1a8d..c66ccc5477 100755
--- a/tests/pytest/fulltest.sh
+++ b/tests/pytest/fulltest.sh
@@ -235,6 +235,8 @@ python3 ./test.py -f query/queryTscomputWithNow.py
python3 ./test.py -f query/computeErrorinWhere.py
python3 ./test.py -f query/queryTsisNull.py
python3 ./test.py -f query/subqueryFilter.py
+# python3 ./test.py -f query/nestedQuery/queryInterval.py
+python3 ./test.py -f query/queryStateWindow.py
#stream
@@ -325,6 +327,7 @@ python3 ./test.py -f query/queryGroupbySort.py
python3 ./test.py -f functions/queryTestCases.py
python3 ./test.py -f functions/function_stateWindow.py
python3 ./test.py -f functions/function_derivative.py
+python3 ./test.py -f functions/function_irate.py
python3 ./test.py -f insert/unsignedInt.py
python3 ./test.py -f insert/unsignedBigint.py
diff --git a/tests/pytest/functions/function_irate.py b/tests/pytest/functions/function_irate.py
new file mode 100644
index 0000000000..2c85e1bbdd
--- /dev/null
+++ b/tests/pytest/functions/function_irate.py
@@ -0,0 +1,228 @@
+###################################################################
+# Copyright (c) 2016 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
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+import numpy as np
+
+
+class TDTestCase:
+ def init(self, conn, logSql):
+ tdLog.debug("start to execute %s" % __file__)
+ tdSql.init(conn.cursor())
+
+ self.rowNum = 100
+ self.ts = 1537146000000
+ self.ts1 = 1537146000000000
+
+
+ def run(self):
+ # db precison ms
+ tdSql.prepare()
+ tdSql.execute('''create table test(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 float, col6 double,
+ col7 bool, col8 binary(20), col9 nchar(20), col11 tinyint unsigned, col12 smallint unsigned, col13 int unsigned, col14 bigint unsigned) tags(loc nchar(20), tag1 int)''')
+ tdSql.execute("create table test1 using test tags('beijing', 10)")
+ tdSql.execute("create table gtest1 (ts timestamp, col1 float)")
+ tdSql.execute("create table gtest2 (ts timestamp, col1 tinyint)")
+ tdSql.execute("create table gtest3 (ts timestamp, col1 tinyint)")
+ tdSql.execute("create table gtest4 (ts timestamp, col1 tinyint)")
+ tdSql.execute("create table gtest5 (ts timestamp, col1 tinyint)")
+ tdSql.execute("create table gtest6 (ts timestamp, col1 tinyint)")
+ tdSql.execute("create table gtest7 (ts timestamp, col1 tinyint)")
+ tdSql.execute("create table gtest8 (ts timestamp, col1 tinyint)")
+
+
+ for i in range(self.rowNum):
+ tdSql.execute("insert into test1 values(%d, %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d', %d, %d, %d, %d)"
+ % (self.ts + i*1000, i + 1, i + 1, i + 1, i + 1, i + 0.1, i + 0.1, i % 2, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1))
+
+ tdSql.execute("insert into gtest1 values(1537146000000,0);")
+ tdSql.execute("insert into gtest1 values(1537146001100,1.2);")
+ tdSql.execute("insert into gtest2 values(1537146001001,1);")
+ tdSql.execute("insert into gtest2 values(1537146001101,2);")
+ tdSql.execute("insert into gtest3 values(1537146001101,2);")
+ tdSql.execute("insert into gtest4(ts) values(1537146001101);")
+ tdSql.execute("insert into gtest5 values(1537146001002,4);")
+ tdSql.execute("insert into gtest5 values(1537146002202,4);")
+ tdSql.execute("insert into gtest6 values(1537146000000,5);")
+ tdSql.execute("insert into gtest6 values(1537146001000,2);")
+ tdSql.execute("insert into gtest7 values(1537146001000,1);")
+ tdSql.execute("insert into gtest7 values(1537146008000,2);")
+ tdSql.execute("insert into gtest7 values(1537146009000,6);")
+ tdSql.execute("insert into gtest7 values(1537146012000,3);")
+ tdSql.execute("insert into gtest7 values(1537146015000,3);")
+ tdSql.execute("insert into gtest7 values(1537146017000,1);")
+ tdSql.execute("insert into gtest7 values(1537146019000,3);")
+ tdSql.execute("insert into gtest8 values(1537146000002,4);")
+ tdSql.execute("insert into gtest8 values(1537146002202,4);")
+
+ # irate verifacation
+ tdSql.query("select irate(col1) from test1;")
+ tdSql.checkData(0, 0, 1)
+ tdSql.query("select irate(col1) from test1 interval(10s);")
+ tdSql.checkData(0, 1, 1)
+ tdSql.query("select irate(col1) from test1;")
+ tdSql.checkData(0, 0, 1)
+ tdSql.query("select irate(col2) from test1;")
+ tdSql.checkData(0, 0, 1)
+ tdSql.query("select irate(col3) from test1;")
+ tdSql.checkData(0, 0, 1)
+ tdSql.query("select irate(col4) from test1;")
+ tdSql.checkData(0, 0, 1)
+ tdSql.query("select irate(col5) from test1;")
+ tdSql.checkData(0, 0, 1)
+ tdSql.query("select irate(col6) from test1;")
+ tdSql.checkData(0, 0, 1)
+ tdSql.query("select irate(col11) from test1;")
+ tdSql.checkData(0, 0, 1)
+ tdSql.query("select irate(col12) from test1;")
+ tdSql.checkData(0, 0, 1)
+ tdSql.query("select irate(col13) from test1;")
+ tdSql.checkData(0, 0, 1)
+ tdSql.query("select irate(col14) from test1;")
+ tdSql.checkData(0, 0, 1)
+ tdSql.query("select irate(col2) from test1;")
+ tdSql.checkData(0, 0, 1)
+ tdSql.query("select irate(col2) from test1;")
+ tdSql.checkData(0, 0, 1)
+
+ tdSql.query("select irate(col1) from gtest1;")
+ tdSql.checkData(0, 0, 1.2/1.1)
+ tdSql.query("select irate(col1) from gtest2;")
+ tdSql.checkData(0, 0, 10)
+ tdSql.query("select irate(col1) from gtest3;")
+ tdSql.checkData(0, 0, 0)
+ tdSql.query("select irate(col1) from gtest4;")
+ tdSql.checkRows(0)
+ tdSql.query("select irate(col1) from gtest5;")
+ tdSql.checkData(0, 0, 0)
+ tdSql.query("select irate(col1) from gtest6;")
+ tdSql.checkData(0, 0, 2)
+ tdSql.query("select irate(col1) from gtest7;")
+ tdSql.checkData(0, 0, 1)
+ tdSql.query("select irate(col1) from gtest7 interval(5s) order by ts asc;")
+ tdSql.checkData(1, 1, 4)
+ tdSql.checkData(2, 1, 0)
+ tdSql.checkData(3, 1, 1)
+ tdSql.query("select irate(col1) from gtest7 interval(5s) order by ts desc ;")
+ tdSql.checkData(1, 1, 0)
+ tdSql.checkData(2, 1, 4)
+ tdSql.checkData(3, 1, 0)
+
+ #error
+ tdSql.error("select irate(col1) from test")
+ tdSql.error("select irate(ts) from test1")
+ tdSql.error("select irate(col7) from test1")
+ tdSql.error("select irate(col8) from test1")
+ tdSql.error("select irate(col9) from test1")
+ tdSql.error("select irate(loc) from test1")
+ tdSql.error("select irate(tag1) from test1")
+
+ # use db1 precision us
+ tdSql.execute("create database db1 precision 'us' keep 3650 UPDATE 1")
+ tdSql.execute("use db1 ")
+ tdSql.execute('''create table test(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 float, col6 double,
+ col7 bool, col8 binary(20), col9 nchar(20), col11 tinyint unsigned, col12 smallint unsigned, col13 int unsigned, col14 bigint unsigned) tags(loc nchar(20))''')
+ tdSql.execute("create table test1 using test tags('beijing')")
+ tdSql.execute("create table gtest1 (ts timestamp, col1 float)")
+ tdSql.execute("create table gtest2 (ts timestamp, col1 tinyint)")
+ tdSql.execute("create table gtest3 (ts timestamp, col1 tinyint)")
+ tdSql.execute("create table gtest4 (ts timestamp, col1 tinyint)")
+ tdSql.execute("create table gtest5 (ts timestamp, col1 tinyint)")
+ tdSql.execute("create table gtest6 (ts timestamp, col1 tinyint)")
+ tdSql.execute("create table gtest7 (ts timestamp, col1 tinyint)")
+ tdSql.execute("create table gtest8 (ts timestamp, col1 tinyint)")
+ tdSql.execute("create table gtest9 (ts timestamp, col1 tinyint)")
+
+ for i in range(self.rowNum):
+ tdSql.execute("insert into test1 values(%d, %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d', %d, %d, %d, %d)"
+ % (self.ts1 + i*1000000, i + 1, i + 1, i + 1, i + 1, i + 0.1, i + 0.1, i % 2, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1))
+
+ tdSql.execute("insert into gtest1 values(1537146000000000,0);")
+ tdSql.execute("insert into gtest1 values(1537146001100000,1.2);")
+ tdSql.execute("insert into gtest2 values(1537146001001000,1);")
+ tdSql.execute("insert into gtest2 values(1537146001101000,2);")
+ tdSql.execute("insert into gtest3 values(1537146001101000,2);")
+ tdSql.execute("insert into gtest4(ts) values(1537146001101000);")
+ tdSql.execute("insert into gtest5 values(1537146001002000,4);")
+ tdSql.execute("insert into gtest5 values(1537146002202000,4);")
+ tdSql.execute("insert into gtest6 values(1537146000000000,5);")
+ tdSql.execute("insert into gtest6 values(1537146001000000,2);")
+ tdSql.execute("insert into gtest7 values(1537146001000000,1);")
+ tdSql.execute("insert into gtest7 values(1537146008000000,2);")
+ tdSql.execute("insert into gtest7 values(1537146009000000,6);")
+ tdSql.execute("insert into gtest7 values(1537146012000000,3);")
+ tdSql.execute("insert into gtest7 values(1537146015000000,3);")
+ tdSql.execute("insert into gtest7 values(1537146017000000,1);")
+ tdSql.execute("insert into gtest7 values(1537146019000000,3);")
+ tdSql.execute("insert into gtest8 values(1537146000002000,3);")
+ tdSql.execute("insert into gtest8 values(1537146001003000,4);")
+ tdSql.execute("insert into gtest9 values(1537146000000000,4);")
+ tdSql.execute("insert into gtest9 values(1537146000000001,5);")
+
+
+ # irate verifacation
+ tdSql.query("select irate(col1) from test1;")
+ tdSql.checkData(0, 0, 1)
+ tdSql.query("select irate(col1) from test1 interval(10s);")
+ tdSql.checkData(0, 1, 1)
+ tdSql.query("select irate(col1) from test1;")
+ tdSql.checkData(0, 0, 1)
+ tdSql.query("select irate(col1) from gtest1;")
+ tdSql.checkData(0, 0, 1.2/1.1)
+ tdSql.query("select irate(col1) from gtest2;")
+ tdSql.checkData(0, 0, 10)
+ tdSql.query("select irate(col1) from gtest3;")
+ tdSql.checkData(0, 0, 0)
+ tdSql.query("select irate(col1) from gtest4;")
+ tdSql.checkRows(0)
+ tdSql.query("select irate(col1) from gtest5;")
+ tdSql.checkData(0, 0, 0)
+ tdSql.query("select irate(col1) from gtest6;")
+ tdSql.checkData(0, 0, 2)
+ tdSql.query("select irate(col1) from gtest7;")
+ tdSql.checkData(0, 0, 1)
+ tdSql.query("select irate(col1) from gtest7 interval(5s) order by ts asc;")
+ tdSql.checkData(1, 1, 4)
+ tdSql.checkData(2, 1, 0)
+ tdSql.checkData(3, 1, 1)
+ tdSql.query("select irate(col1) from gtest7 interval(5s) order by ts desc ;")
+ tdSql.checkData(1, 1, 0)
+ tdSql.checkData(2, 1, 4)
+ tdSql.checkData(3, 1, 0)
+ tdSql.query("select irate(col1) from gtest8;")
+ tdSql.checkData(0, 0, 1/1.001)
+ tdSql.query("select irate(col1) from gtest9;")
+ tdSql.checkData(0, 0, 1000000)
+
+ #error
+ tdSql.error("select irate(col1) from test")
+ tdSql.error("select irate(ts) from test1")
+ tdSql.error("select irate(col7) from test1")
+ tdSql.error("select irate(col8) from test1")
+ tdSql.error("select irate(col9) from test1")
+ tdSql.error("select irate(loc) from test1")
+ tdSql.error("select irate(tag1) from test1")
+
+
+
+
+ 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/in_function.py b/tests/pytest/insert/in_function.py
index d1fbfd702a..3f2e1a03ca 100644
--- a/tests/pytest/insert/in_function.py
+++ b/tests/pytest/insert/in_function.py
@@ -18,7 +18,6 @@ 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__)
@@ -27,6 +26,7 @@ class TDTestCase:
def run(self):
tdSql.prepare()
# test case for https://jira.taosdata.com:18080/browse/TD-4568
+ # test case for https://jira.taosdata.com:18080/browse/TD-4824
tdLog.info("=============== step1,check bool and tinyint data type")
@@ -137,8 +137,28 @@ class TDTestCase:
tdSql.checkData(0,1,'True')
tdSql.checkData(0,2,'0')
+ tdLog.info("=============== step1.3,multiple column and multiple tag check in function")
+ cmd1 = '''select * from in_stable_1
+ where in_bool in (true,false) and in_tinyint in (0,127,-127)
+ and tin_bool in (true,false) and tin_tinyint in (0,127,-127)
+ order by ts desc ;'''
+ tdLog.info(cmd1)
+ tdSql.query(cmd1)
+ tdSql.checkData(0,1,'True')
+ tdSql.checkData(0,2,'0')
+ tdSql.checkData(0,3,'False')
+ tdSql.checkData(0,4,'0')
+ tdSql.checkData(1,1,'False')
+ tdSql.checkData(1,2,'127')
+ tdSql.checkData(1,3,'False')
+ tdSql.checkData(1,4,'-127')
+ tdSql.checkData(2,1,'True')
+ tdSql.checkData(2,2,'-127')
+ tdSql.checkData(2,3,'True')
+ tdSql.checkData(2,4,'127')
- tdLog.info("=============== step1.3,drop normal table && create table")
+
+ tdLog.info("=============== step1.4,drop normal table && create table")
cmd1 = 'drop table if exists normal_in_bool_tinyint_1 ;'
cmd2 = 'create table normal_in_bool_tinyint_1 (ts timestamp,in_bool bool,in_tinyint tinyint) ; '
tdLog.info(cmd1)
@@ -147,7 +167,7 @@ class TDTestCase:
tdSql.execute(cmd2)
- tdLog.info("=============== step1.4,insert normal table right data and check in function")
+ tdLog.info("=============== step1.5,insert normal table right data and check in function")
cmd1 = 'insert into normal_in_bool_tinyint_1 values(now,\'true\',\'-127\') ;'
tdLog.info(cmd1)
tdSql.execute(cmd1)
@@ -175,6 +195,17 @@ class TDTestCase:
tdSql.checkData(0,1,'True')
tdSql.checkData(0,2,'0')
+ cmd4 = '''select * from normal_in_bool_tinyint_1
+ where in_bool in (true,false) and in_tinyint in (0,127,-127)
+ order by ts desc ;'''
+ tdLog.info(cmd4)
+ tdSql.query(cmd4)
+ tdSql.checkData(0,1,'True')
+ tdSql.checkData(0,2,'0')
+ tdSql.checkData(1,1,'False')
+ tdSql.checkData(1,2,'127')
+ tdSql.checkData(2,1,'True')
+ tdSql.checkData(2,2,'-127')
tdLog.info("=============== step2,check int、smallint and bigint data type")
@@ -378,10 +409,39 @@ class TDTestCase:
tdSql.query('select * from in_int_smallint_bigint_3 where in_big in (-9223372036854775807) order by ts desc')
tdSql.checkData(0,1,'0')
tdSql.checkData(0,2,'32767')
- tdSql.checkData(0,3,'-9223372036854775807')
+ tdSql.checkData(0,3,'-9223372036854775807')
- tdLog.info("=============== step2.3,drop normal table && create table")
+ tdLog.info("=============== step2.3,multiple column and multiple tag check in function")
+ cmd1 = '''select * from in_stable_2
+ where in_int in (0,2147483647,-2147483647) and in_small in (0,32767,-32767)
+ and in_big in (0,9223372036854775807,-9223372036854775807)
+ and tin_int in (0,2147483647,-2147483647) and tin_small in (0,32767,-32767)
+ and tin_big in (0,9223372036854775807,-9223372036854775807)
+ order by ts desc ;'''
+ tdLog.info(cmd1)
+ tdSql.query(cmd1)
+ tdSql.checkData(0,1,'0')
+ tdSql.checkData(0,2,'32767')
+ tdSql.checkData(0,3,'-9223372036854775807')
+ tdSql.checkData(0,4,'0')
+ tdSql.checkData(0,5,'32767')
+ tdSql.checkData(0,6,'-9223372036854775807')
+ tdSql.checkData(1,1,'-2147483647')
+ tdSql.checkData(1,2,'0')
+ tdSql.checkData(1,3,'9223372036854775807')
+ tdSql.checkData(1,4,'-2147483647')
+ tdSql.checkData(1,5,'0')
+ tdSql.checkData(1,6,'9223372036854775807')
+ tdSql.checkData(2,1,'2147483647')
+ tdSql.checkData(2,2,'-32767')
+ tdSql.checkData(2,3,'0')
+ tdSql.checkData(2,4,'2147483647')
+ tdSql.checkData(2,5,'-32767')
+ tdSql.checkData(2,6,'0')
+
+
+ tdLog.info("=============== step2.4,drop normal table && create table")
cmd1 = 'drop table if exists normal_int_smallint_bigint_1 ;'
cmd2 = 'create table normal_int_smallint_bigint_1 (ts timestamp,in_int int,in_small smallint , in_big bigint) ; '
tdLog.info(cmd1)
@@ -390,7 +450,7 @@ class TDTestCase:
tdSql.execute(cmd2)
- tdLog.info("=============== step2.4,insert normal table right data and check in function")
+ tdLog.info("=============== step2.5,insert normal table right data and check in function")
cmd1 = 'insert into normal_int_smallint_bigint_1 values(now,\'2147483647\',\'-32767\',\'0\') ;'
tdLog.info(cmd1)
tdSql.execute(cmd1)
@@ -437,7 +497,23 @@ class TDTestCase:
tdSql.query('select * from normal_int_smallint_bigint_1 where in_big in (-9223372036854775807) order by ts desc')
tdSql.checkData(0,1,'0')
tdSql.checkData(0,2,'32767')
- tdSql.checkData(0,3,'-9223372036854775807')
+ tdSql.checkData(0,3,'-9223372036854775807')
+
+ cmd4 = '''select * from normal_int_smallint_bigint_1
+ where in_int in (0,2147483647,-2147483647) and in_small in (0,32767,-32767)
+ and in_big in (0,9223372036854775807,-9223372036854775807)
+ order by ts desc ;'''
+ tdLog.info(cmd4)
+ tdSql.query(cmd4)
+ tdSql.checkData(0,1,'0')
+ tdSql.checkData(0,2,'32767')
+ tdSql.checkData(0,3,'-9223372036854775807')
+ tdSql.checkData(1,1,'-2147483647')
+ tdSql.checkData(1,2,'0')
+ tdSql.checkData(1,3,'9223372036854775807')
+ tdSql.checkData(2,1,'2147483647')
+ tdSql.checkData(2,2,'-32767')
+ tdSql.checkData(2,3,'0')
tdLog.info("=============== step3,check binary and nchar data type")
@@ -560,7 +636,30 @@ class TDTestCase:
tdSql.checkData(0,2,'北京涛思数据科技有限公司')
- tdLog.info("=============== step3.3,drop normal table && create table")
+ tdLog.info("=============== step3.3,multiple column and multiple tag check in function")
+ cmd1 = '''select * from in_stable_3
+ where in_binary in (\'0\',\'TDengine\',\'TAOS\')
+ and in_nchar in (\'0\',\'北京涛思数据科技有限公司\',\'涛思数据TAOSdata\')
+ and tin_binary in (\'0\',\'TDengine\',\'taosdataTDengine\')
+ and tin_nchar in (\'0\',\'北京涛思数据科技有限公司\',\'北京涛思数据科技有限公司TDengine\')
+ order by ts desc ;'''
+ tdLog.info(cmd1)
+ tdSql.query(cmd1)
+ tdSql.checkData(0,1,'TDengine')
+ tdSql.checkData(0,2,'北京涛思数据科技有限公司')
+ tdSql.checkData(0,3,'taosdataTDengine')
+ tdSql.checkData(0,4,'北京涛思数据科技有限公司TDengine')
+ tdSql.checkData(1,1,'TAOS')
+ tdSql.checkData(1,2,'涛思数据TAOSdata')
+ tdSql.checkData(1,3,'TDengine')
+ tdSql.checkData(1,4,'北京涛思数据科技有限公司')
+ tdSql.checkData(2,1,'0')
+ tdSql.checkData(2,2,'0')
+ tdSql.checkData(2,3,'0')
+ tdSql.checkData(2,4,'0')
+
+
+ tdLog.info("=============== step3.4,drop normal table && create table")
cmd1 = 'drop table if exists normal_in_binary_nchar_1 ;'
cmd2 = 'create table normal_in_binary_nchar_1 (ts timestamp,in_binary binary(8),in_nchar nchar(12)) ; '
tdLog.info(cmd1)
@@ -569,7 +668,7 @@ class TDTestCase:
tdSql.execute(cmd2)
- tdLog.info("=============== step3.4,insert normal table right data and check in function")
+ tdLog.info("=============== step3.5,insert normal table right data and check in function")
cmd1 = 'insert into normal_in_binary_nchar_1 values(now,\'0\',\'0\') ;'
tdLog.info(cmd1)
tdSql.execute(cmd1)
@@ -598,124 +697,413 @@ class TDTestCase:
tdSql.checkData(0,2,'北京涛思数据科技有限公司')
tdSql.query('select * from normal_in_binary_nchar_1 where in_nchar in (\'北京涛思数据科技有限公司\') order by ts desc')
tdSql.checkData(0,1,'TDengine')
- tdSql.checkData(0,2,'北京涛思数据科技有限公司')
+ tdSql.checkData(0,2,'北京涛思数据科技有限公司')
- tdLog.info("=============== step4,check float and double data type,not support")
+ cmd4 = '''select * from normal_in_binary_nchar_1
+ where in_binary in (\'0\',\'TDengine\',\'TAOS\')
+ and in_nchar in (\'0\',\'北京涛思数据科技有限公司\',\'涛思数据TAOSdata\')
+ order by ts desc ;'''
+ tdLog.info(cmd4)
+ tdSql.query(cmd4)
+ tdSql.checkData(0,1,'TDengine')
+ tdSql.checkData(0,2,'北京涛思数据科技有限公司')
+ tdSql.checkData(1,1,'TAOS')
+ tdSql.checkData(1,2,'涛思数据TAOSdata')
+ tdSql.checkData(2,1,'0')
+ tdSql.checkData(2,2,'0')
+
+
+ tdLog.info("=============== step4,check float and double data type")
tdLog.info("=============== step4.1,drop table && create table")
- cmd1 = 'drop table if exists in_float_double_1 ;'
+ cmd1 = 'drop table if exists in_ts_float_double_1 ;'
+ cmd2 = 'drop table if exists in_ts_float_double_2 ;'
+ cmd3 = 'drop table if exists in_ts_float_double_3 ;'
cmd10 = 'drop table if exists in_stable_4 ;'
- cmd11 = 'create stable in_stable_4(ts timestamp,in_float float,in_double double) tags (tin_float float,tin_double double) ;'
- cmd12 = 'create table in_float_double_1 using in_stable_4 tags(\'666\',\'88888\') ; '
+ cmd11 = 'create stable in_stable_4(ts timestamp,in_ts timestamp,in_float float,in_double double) tags (tin_ts timestamp,tin_float float,tin_double double) ;'
+ cmd12 = 'create table in_ts_float_double_1 using in_stable_4 tags(\'0\',\'0\',\'0\') ; '
+ cmd13 = 'create table in_ts_float_double_2 using in_stable_4 tags(\'2020-01-01 08:00:00.001\',\'666\',\'-88888\') ; '
+ cmd14 = 'create table in_ts_float_double_3 using in_stable_4 tags(\'2021-01-01 08:00:00.001\',\'-888.00000\',\'66666.000000000\') ; '
tdLog.info(cmd1)
tdSql.execute(cmd1)
+ tdLog.info(cmd2)
+ tdSql.execute(cmd2)
+ tdLog.info(cmd3)
+ tdSql.execute(cmd3)
tdLog.info(cmd10)
tdSql.execute(cmd10)
tdLog.info(cmd11)
tdSql.execute(cmd11)
tdLog.info(cmd12)
tdSql.execute(cmd12)
+ tdLog.info(cmd13)
+ tdSql.execute(cmd13)
+ tdLog.info(cmd14)
+ tdSql.execute(cmd14)
tdLog.info("=============== step4.2,insert stable right data and check in function")
- cmd1 = 'insert into in_float_double_1 values(now,\'888\',\'66666\') ;'
+ cmd1 = 'insert into in_ts_float_double_1 values(now,\'0\',\'0\',\'0\') ;'
tdLog.info(cmd1)
- tdSql.execute(cmd1)
+ tdSql.execute(cmd1)
+
+ tdSql.query('select * from in_stable_4 where in_ts in (\'0\') order by ts desc')
+ tdSql.checkData(0,1,'1970-01-01 08:00:00.000')
+ tdSql.checkData(0,2,0.00000)
+ tdSql.checkData(0,3,0.000000000)
+ tdSql.checkData(0,4,'1970-01-01 08:00:00.000')
+ tdSql.checkData(0,5,0.00000)
+ tdSql.checkData(0,6,0.000000000)
+ tdSql.query('select * from in_stable_4 where in_ts in (\'1970-01-01 08:00:00.000\') order by ts desc')
+ tdSql.checkData(0,1,'1970-01-01 08:00:00.000')
+ tdSql.checkData(0,2,0.00000)
+ tdSql.checkData(0,3,0.000000000)
+ tdSql.checkData(0,4,'1970-01-01 08:00:00.000')
+ tdSql.checkData(0,5,0.00000)
+ tdSql.checkData(0,6,0.000000000)
+ tdSql.query('select * from in_stable_4 where in_float in (0.00000) order by ts desc')
+ tdSql.checkData(0,1,'1970-01-01 08:00:00.000')
+ tdSql.checkData(0,2,0.00000)
+ tdSql.checkData(0,3,0.000000000)
+ tdSql.checkData(0,4,'1970-01-01 08:00:00.000')
+ tdSql.checkData(0,5,0.00000)
+ tdSql.checkData(0,6,0.000000000)
+ tdSql.query('select * from in_stable_4 where in_double in (0.000000000) order by ts desc')
+ tdSql.checkData(0,1,'1970-01-01 08:00:00.000')
+ tdSql.checkData(0,2,0.00000)
+ tdSql.checkData(0,3,0.000000000)
+ tdSql.checkData(0,4,'1970-01-01 08:00:00.000')
+ tdSql.checkData(0,5,0.00000)
+ tdSql.checkData(0,6,0.000000000)
+
+ tdSql.query('select * from in_stable_4 where tin_ts in (\'0\') order by ts desc')
+ tdSql.checkData(0,1,'1970-01-01 08:00:00.000')
+ tdSql.checkData(0,2,0.00000)
+ tdSql.checkData(0,3,0.000000000)
+ tdSql.checkData(0,4,'1970-01-01 08:00:00.000')
+ tdSql.checkData(0,5,0.00000)
+ tdSql.checkData(0,6,0.000000000)
+ tdSql.query('select * from in_stable_4 where tin_ts in (\'1970-01-01 08:00:00.000\') order by ts desc')
+ tdSql.checkData(0,1,'1970-01-01 08:00:00.000')
+ tdSql.checkData(0,2,0.00000)
+ tdSql.checkData(0,3,0.000000000)
+ tdSql.checkData(0,4,'1970-01-01 08:00:00.000')
+ tdSql.checkData(0,5,0.00000)
+ tdSql.checkData(0,6,0.000000000)
+ tdSql.query('select * from in_stable_4 where tin_float in (0.00000) order by ts desc')
+ tdSql.checkData(0,1,'1970-01-01 08:00:00.000')
+ tdSql.checkData(0,2,0.00000)
+ tdSql.checkData(0,3,0.000000000)
+ tdSql.checkData(0,4,'1970-01-01 08:00:00.000')
+ tdSql.checkData(0,5,0.00000)
+ tdSql.checkData(0,6,0.000000000)
+ tdSql.query('select * from in_stable_4 where tin_double in (0.000000000) order by ts desc')
+ tdSql.checkData(0,1,'1970-01-01 08:00:00.000')
+ tdSql.checkData(0,2,0.00000)
+ tdSql.checkData(0,3,0.000000000)
+ tdSql.checkData(0,4,'1970-01-01 08:00:00.000')
+ tdSql.checkData(0,5,0.00000)
+ tdSql.checkData(0,6,0.000000000)
+
+ tdSql.query('select * from in_ts_float_double_1 where in_ts in (\'0\') order by ts desc')
+ tdSql.checkData(0,1,'1970-01-01 08:00:00.000')
+ tdSql.checkData(0,2,0.00000)
+ tdSql.checkData(0,3,0.000000000)
+ tdSql.query('select * from in_ts_float_double_1 where in_ts in (\'1970-01-01 08:00:00.000\') order by ts desc')
+ tdSql.checkData(0,1,'1970-01-01 08:00:00.000')
+ tdSql.checkData(0,2,0.00000)
+ tdSql.checkData(0,3,0.000000000)
+ tdSql.query('select * from in_ts_float_double_1 where in_float in (0.00000) order by ts desc')
+ tdSql.checkData(0,1,'1970-01-01 08:00:00.000')
+ tdSql.checkData(0,2,0.00000)
+ tdSql.checkData(0,3,0.000000000)
+ tdSql.query('select * from in_ts_float_double_1 where in_double in (0.000000000) order by ts desc')
+ tdSql.checkData(0,1,'1970-01-01 08:00:00.000')
+ tdSql.checkData(0,2,0.00000)
+ tdSql.checkData(0,3,0.000000000)
- cmd2 = 'select * from in_stable_4 where in_float in (\'888\');'
+ cmd2 = 'insert into in_ts_float_double_2 values(now,\'2020-01-01 08:00:00.001\',\'666\',\'-88888\') ;'
tdLog.info(cmd2)
- tdSql.error(cmd2)
- try:
- tdSql.execute(cmd2)
- tdLog.exit("invalid operation: not supported filter condition")
- except Exception as e:
- tdLog.info(repr(e))
- tdLog.info("invalid operation: not supported filter condition")
+ tdSql.execute(cmd2)
+
+ tdSql.query('select * from in_stable_4 where in_ts in (\'2020-01-01 08:00:00.001\') order by ts desc')
+ tdSql.checkData(0,1,'2020-01-01 08:00:00.001000')
+ tdSql.checkData(0,2,666.00000)
+ tdSql.checkData(0,3,-88888.000000000)
+ tdSql.checkData(0,4,'2020-01-01 08:00:00.001')
+ tdSql.checkData(0,5,666.00000)
+ tdSql.checkData(0,6,-88888.000000000)
+ tdSql.query('select * from in_stable_4 where in_ts in (\'1577836800001\') order by ts desc')
+ tdSql.checkData(0,1,'2020-01-01 08:00:00.001000')
+ tdSql.checkData(0,2,666.00000)
+ tdSql.checkData(0,3,-88888.000000000)
+ tdSql.checkData(0,4,'2020-01-01 08:00:00.001')
+ tdSql.checkData(0,5,666.00000)
+ tdSql.checkData(0,6,-88888.000000000)
+ tdSql.query('select * from in_stable_4 where in_float in (666.00000) order by ts desc')
+ tdSql.checkData(0,1,'2020-01-01 08:00:00.001000')
+ tdSql.checkData(0,2,666.00000)
+ tdSql.checkData(0,3,-88888.000000000)
+ tdSql.checkData(0,4,'2020-01-01 08:00:00.001')
+ tdSql.checkData(0,5,666.00000)
+ tdSql.checkData(0,6,-88888.000000000)
+ tdSql.query('select * from in_stable_4 where in_double in (-88888.000000000) order by ts desc')
+ tdSql.checkData(0,1,'2020-01-01 08:00:00.001000')
+ tdSql.checkData(0,2,666.00000)
+ tdSql.checkData(0,3,-88888.000000000)
+ tdSql.checkData(0,4,'2020-01-01 08:00:00.001')
+ tdSql.checkData(0,5,666.00000)
+ tdSql.checkData(0,6,-88888.000000000)
+
+ tdSql.query('select * from in_stable_4 where tin_ts in (\'2020-01-01 08:00:00.001000\') order by ts desc')
+ tdSql.checkData(0,1,'2020-01-01 08:00:00.001000')
+ tdSql.checkData(0,2,666.00000)
+ tdSql.checkData(0,3,-88888.000000000)
+ tdSql.checkData(0,4,'2020-01-01 08:00:00.001')
+ tdSql.checkData(0,5,666.00000)
+ tdSql.checkData(0,6,-88888.000000000)
+ tdSql.query('select * from in_stable_4 where tin_ts in (\'1577836800001\') order by ts desc')
+ tdSql.checkData(0,1,'2020-01-01 08:00:00.001000')
+ tdSql.checkData(0,2,666.00000)
+ tdSql.checkData(0,3,-88888.000000000)
+ tdSql.checkData(0,4,'2020-01-01 08:00:00.001')
+ tdSql.checkData(0,5,666.00000)
+ tdSql.checkData(0,6,-88888.000000000)
+ tdSql.query('select * from in_stable_4 where tin_float in (666.00000) order by ts desc')
+ tdSql.checkData(0,1,'2020-01-01 08:00:00.001000')
+ tdSql.checkData(0,2,666.00000)
+ tdSql.checkData(0,3,-88888.000000000)
+ tdSql.checkData(0,4,'2020-01-01 08:00:00.001')
+ tdSql.checkData(0,5,666.00000)
+ tdSql.checkData(0,6,-88888.000000000)
+ tdSql.query('select * from in_stable_4 where tin_double in (-88888.000000000) order by ts desc')
+ tdSql.checkData(0,1,'2020-01-01 08:00:00.001000')
+ tdSql.checkData(0,2,666.00000)
+ tdSql.checkData(0,3,-88888.000000000)
+ tdSql.checkData(0,4,'2020-01-01 08:00:00.001')
+ tdSql.checkData(0,5,666.00000)
+ tdSql.checkData(0,6,-88888.000000000)
+
+ tdSql.query('select * from in_ts_float_double_2 where in_ts in (\'1577836800001\') order by ts desc')
+ tdSql.checkData(0,1,'2020-01-01 08:00:00.001')
+ tdSql.checkData(0,2,666.00000)
+ tdSql.checkData(0,3,-88888.000000000)
+ tdSql.query('select * from in_ts_float_double_2 where in_ts in (\'2020-01-01 08:00:00.001\') order by ts desc')
+ tdSql.checkData(0,1,'2020-01-01 08:00:00.001')
+ tdSql.checkData(0,2,666.00000)
+ tdSql.checkData(0,3,-88888.000000000)
+ tdSql.query('select * from in_ts_float_double_2 where in_float in (666.00000) order by ts desc')
+ tdSql.checkData(0,1,'2020-01-01 08:00:00.001')
+ tdSql.checkData(0,2,666.00000)
+ tdSql.checkData(0,3,-88888.000000000)
+ tdSql.query('select * from in_ts_float_double_2 where in_double in (-88888.000000000) order by ts desc')
+ tdSql.checkData(0,1,'2020-01-01 08:00:00.001')
+ tdSql.checkData(0,2,666.00000)
+ tdSql.checkData(0,3,-88888.000000000)
- cmd3 = 'select * from in_stable_4 where in_double in (\'66666\');'
+ cmd3 = 'insert into in_ts_float_double_3 values(now,\'2021-01-01 08:00:00.001\',\'-888.00000\',\'66666.000000000\') ;'
tdLog.info(cmd3)
- tdSql.error(cmd3)
- try:
- tdSql.execute(cmd3)
- tdLog.exit("invalid operation: not supported filter condition")
- except Exception as e:
- tdLog.info(repr(e))
- tdLog.info("invalid operation: not supported filter condition")
+ tdSql.execute(cmd3)
- cmd4 = 'select * from in_stable_4 where tin_float in (\'666\');'
- tdLog.info(cmd4)
- tdSql.error(cmd4)
- try:
- tdSql.execute(cmd4)
- tdLog.exit("invalid operation: not supported filter condition")
- except Exception as e:
- tdLog.info(repr(e))
- tdLog.info("invalid operation: not supported filter condition")
+ tdSql.query('select * from in_stable_4 where in_ts in (\'2021-01-01 08:00:00.001\') order by ts desc')
+ tdSql.checkData(0,1,'2021-01-01 08:00:00.001000')
+ tdSql.checkData(0,2,-888.00000)
+ tdSql.checkData(0,3,66666.000000000)
+ tdSql.checkData(0,4,'2021-01-01 08:00:00.001')
+ tdSql.checkData(0,5,-888.00000)
+ tdSql.checkData(0,6,66666.000000000)
+ tdSql.query('select * from in_stable_4 where in_ts in (\'1609459200001\') order by ts desc')
+ tdSql.checkData(0,1,'2021-01-01 08:00:00.001000')
+ tdSql.checkData(0,2,-888.00000)
+ tdSql.checkData(0,3,66666.000000000)
+ tdSql.checkData(0,4,'2021-01-01 08:00:00.001')
+ tdSql.checkData(0,5,-888.00000)
+ tdSql.checkData(0,6,66666.000000000)
+ tdSql.query('select * from in_stable_4 where in_float in (-888.00000) order by ts desc')
+ tdSql.checkData(0,1,'2021-01-01 08:00:00.001000')
+ tdSql.checkData(0,2,-888.00000)
+ tdSql.checkData(0,3,66666.000000000)
+ tdSql.checkData(0,4,'2021-01-01 08:00:00.001')
+ tdSql.checkData(0,5,-888.00000)
+ tdSql.checkData(0,6,66666.000000000)
+ tdSql.query('select * from in_stable_4 where in_double in (66666.000000000) order by ts desc')
+ tdSql.checkData(0,1,'2021-01-01 08:00:00.001000')
+ tdSql.checkData(0,2,-888.00000)
+ tdSql.checkData(0,3,66666.000000000)
+ tdSql.checkData(0,4,'2021-01-01 08:00:00.001')
+ tdSql.checkData(0,5,-888.00000)
+ tdSql.checkData(0,6,66666.000000000)
+
+ tdSql.query('select * from in_stable_4 where tin_ts in (\'2021-01-01 08:00:00.001000\') order by ts desc')
+ tdSql.checkData(0,1,'2021-01-01 08:00:00.001000')
+ tdSql.checkData(0,2,-888.00000)
+ tdSql.checkData(0,3,66666.000000000)
+ tdSql.checkData(0,4,'2021-01-01 08:00:00.001')
+ tdSql.checkData(0,5,-888.00000)
+ tdSql.checkData(0,6,66666.000000000)
+ tdSql.query('select * from in_stable_4 where tin_ts in (\'1609459200001\') order by ts desc')
+ tdSql.checkData(0,1,'2021-01-01 08:00:00.001000')
+ tdSql.checkData(0,2,-888.00000)
+ tdSql.checkData(0,3,66666.000000000)
+ tdSql.checkData(0,4,'2021-01-01 08:00:00.001')
+ tdSql.checkData(0,5,-888.00000)
+ tdSql.checkData(0,6,66666.000000000)
+ tdSql.query('select * from in_stable_4 where tin_float in (-888.00000) order by ts desc')
+ tdSql.checkData(0,1,'2021-01-01 08:00:00.001000')
+ tdSql.checkData(0,2,-888.00000)
+ tdSql.checkData(0,3,66666.000000000)
+ tdSql.checkData(0,4,'2021-01-01 08:00:00.001')
+ tdSql.checkData(0,5,-888.00000)
+ tdSql.checkData(0,6,66666.000000000)
+ tdSql.query('select * from in_stable_4 where tin_double in (66666.000000000) order by ts desc')
+ tdSql.checkData(0,1,'2021-01-01 08:00:00.001000')
+ tdSql.checkData(0,2,-888.00000)
+ tdSql.checkData(0,3,66666.000000000)
+ tdSql.checkData(0,4,'2021-01-01 08:00:00.001')
+ tdSql.checkData(0,5,-888.00000)
+ tdSql.checkData(0,6,66666.000000000)
+
+ tdSql.query('select * from in_ts_float_double_3 where in_ts in (\'1609459200001\') order by ts desc')
+ tdSql.checkData(0,1,'2021-01-01 08:00:00.001')
+ tdSql.checkData(0,2,-888.00000)
+ tdSql.checkData(0,3,66666.000000000)
+ tdSql.query('select * from in_ts_float_double_3 where in_ts in (\'2021-01-01 08:00:00.001\') order by ts desc')
+ tdSql.checkData(0,1,'2021-01-01 08:00:00.001')
+ tdSql.checkData(0,2,-888.00000)
+ tdSql.checkData(0,3,66666.000000000)
+ tdSql.query('select * from in_ts_float_double_3 where in_float in (-888.00000) order by ts desc')
+ tdSql.checkData(0,1,'2021-01-01 08:00:00.001')
+ tdSql.checkData(0,2,-888.00000)
+ tdSql.checkData(0,3,66666.000000000)
+ tdSql.query('select * from in_ts_float_double_3 where in_double in (66666.000000000) order by ts desc')
+ tdSql.checkData(0,1,'2021-01-01 08:00:00.001')
+ tdSql.checkData(0,2,-888.00000)
+ tdSql.checkData(0,3,66666.000000000)
+
+
+ tdLog.info("=============== step4.3,multiple column and multiple tag check in function")
+ cmd1 = '''select * from in_stable_4
+ where in_ts in (\'1609459200001\',\'2021-01-01 08:00:00.001\',\'1577836800001\',\'2020-01-01 08:00:00.001000\',\'0\',\'1970-01-01 08:00:00.000\')
+ and in_float in (0.00000,666.00000,-888.00000)
+ and in_double in (0.000000000,66666.000000000,-88888.000000000)
+ and tin_ts in (\'1609459200001\',\'2021-01-01 08:00:00.001\',\'1577836800001\',\'2020-01-01 08:00:00.001000\',\'0\',\'1970-01-01 08:00:00.000\')
+ and tin_float in (0.00000,666.00000,-888.00000)
+ and tin_double in (0.000000000,66666.000000000,-88888.000000000)
+ order by ts desc ;'''
+ tdLog.info(cmd1)
+ tdSql.query(cmd1)
+ tdSql.checkData(0,1,'2021-01-01 08:00:00.001000')
+ tdSql.checkData(0,2,-888.00000)
+ tdSql.checkData(0,3,66666.000000000)
+ tdSql.checkData(0,4,'2021-01-01 08:00:00.001')
+ tdSql.checkData(0,5,-888.00000)
+ tdSql.checkData(0,6,66666.000000000)
+ tdSql.checkData(1,1,'2020-01-01 08:00:00.001000')
+ tdSql.checkData(1,2,666.00000)
+ tdSql.checkData(1,3,-88888.000000000)
+ tdSql.checkData(1,4,'2020-01-01 08:00:00.001')
+ tdSql.checkData(1,5,666.00000)
+ tdSql.checkData(1,6,-88888.000000000)
+ tdSql.checkData(2,1,'1970-01-01 08:00:00.000')
+ tdSql.checkData(2,2,0.00000)
+ tdSql.checkData(2,3,0.000000000)
+ tdSql.checkData(2,4,'1970-01-01 08:00:00.000')
+ tdSql.checkData(2,5,0.00000)
+ tdSql.checkData(2,6,0.000000000)
+
- cmd5 = 'select * from in_stable_4 where tin_double in (\'88888\');'
- tdLog.info(cmd5)
- tdSql.error(cmd5)
- try:
- tdSql.execute(cmd5)
- tdLog.exit("invalid operation: not supported filter condition")
- except Exception as e:
- tdLog.info(repr(e))
- tdLog.info("invalid operation: not supported filter condition")
-
- cmd6 = 'select * from in_float_double_1 where in_float in (\'888\');'
- tdLog.info(cmd6)
- tdSql.error(cmd6)
- try:
- tdSql.execute(cmd6)
- tdLog.exit("invalid operation: not supported filter condition")
- except Exception as e:
- tdLog.info(repr(e))
- tdLog.info("invalid operation: not supported filter condition")
-
- cmd7 = 'select * from in_float_double_1 where in_double in (\'66666\');'
- tdLog.info(cmd7)
- tdSql.error(cmd7)
- try:
- tdSql.execute(cmd7)
- tdLog.exit("invalid operation: not supported filter condition")
- except Exception as e:
- tdLog.info(repr(e))
- tdLog.info("invalid operation: not supported filter condition")
-
- tdLog.info("=============== step4.3,drop normal table && create table")
- cmd1 = 'drop table if exists normal_in_float_double_1 ;'
- cmd2 = 'create table normal_in_float_double_1 (ts timestamp,in_float float,in_double double) ; '
+ tdLog.info("=============== step4.4,drop normal table && create table")
+ cmd1 = 'drop table if exists normal_in_ts_float_double_1 ;'
+ cmd2 = 'create table normal_in_ts_float_double_1 (ts timestamp,in_ts timestamp,in_float float,in_double double) ; '
tdLog.info(cmd1)
tdSql.execute(cmd1)
tdLog.info(cmd2)
tdSql.execute(cmd2)
- tdLog.info("=============== step4.4,insert normal table right data and check in function")
- cmd1 = 'insert into normal_in_float_double_1 values(now,\'888\',\'666666\') ;'
+ tdLog.info("=============== step4.5,insert normal table right data and check in function")
+ cmd1 = 'insert into normal_in_ts_float_double_1 values(now,\'0\',\'0\',\'0\') ;'
tdLog.info(cmd1)
- tdSql.execute(cmd1)
+ tdSql.execute(cmd1)
- cmd2 = 'select * from normal_in_float_double_1 where in_float in (\'888\');'
+ tdSql.query('select * from normal_in_ts_float_double_1 where in_ts in (\'0\') order by ts desc')
+ tdSql.checkData(0,1,'1970-01-01 08:00:00.000')
+ tdSql.checkData(0,2,0.00000)
+ tdSql.checkData(0,3,0.000000000)
+ tdSql.query('select * from normal_in_ts_float_double_1 where in_ts in (\'1970-01-01 08:00:00.000\') order by ts desc')
+ tdSql.checkData(0,1,'1970-01-01 08:00:00.000')
+ tdSql.checkData(0,2,0.00000)
+ tdSql.checkData(0,3,0.000000000)
+ tdSql.query('select * from normal_in_ts_float_double_1 where in_float in (0.00000) order by ts desc')
+ tdSql.checkData(0,1,'1970-01-01 08:00:00.000')
+ tdSql.checkData(0,2,0.00000)
+ tdSql.checkData(0,3,0.000000000)
+ tdSql.query('select * from normal_in_ts_float_double_1 where in_double in (0.000000000) order by ts desc')
+ tdSql.checkData(0,1,'1970-01-01 08:00:00.000')
+ tdSql.checkData(0,2,0.00000)
+ tdSql.checkData(0,3,0.000000000)
+
+ cmd2 = 'insert into normal_in_ts_float_double_1 values(now,\'2020-01-01 08:00:00.001\',\'666\',\'-88888\') ;'
tdLog.info(cmd2)
- tdSql.error(cmd2)
- try:
- tdSql.execute(cmd2)
- tdLog.exit("invalid operation: not supported filter condition")
- except Exception as e:
- tdLog.info(repr(e))
- tdLog.info("invalid operation: not supported filter condition")
-
- cmd3 = 'select * from normal_in_float_double_1 where in_double in (\'66666\');'
+ tdSql.execute(cmd2)
+
+ tdSql.query('select * from normal_in_ts_float_double_1 where in_ts in (\'1577836800001\') order by ts desc')
+ tdSql.checkData(0,1,'2020-01-01 08:00:00.001')
+ tdSql.checkData(0,2,666.00000)
+ tdSql.checkData(0,3,-88888.000000000)
+ tdSql.query('select * from normal_in_ts_float_double_1 where in_ts in (\'2020-01-01 08:00:00.001\') order by ts desc')
+ tdSql.checkData(0,1,'2020-01-01 08:00:00.001')
+ tdSql.checkData(0,2,666.00000)
+ tdSql.checkData(0,3,-88888.000000000)
+ tdSql.query('select * from normal_in_ts_float_double_1 where in_float in (666.00000) order by ts desc')
+ tdSql.checkData(0,1,'2020-01-01 08:00:00.001')
+ tdSql.checkData(0,2,666.00000)
+ tdSql.checkData(0,3,-88888.000000000)
+ tdSql.query('select * from normal_in_ts_float_double_1 where in_double in (-88888.000000000) order by ts desc')
+ tdSql.checkData(0,1,'2020-01-01 08:00:00.001')
+ tdSql.checkData(0,2,666.00000)
+ tdSql.checkData(0,3,-88888.000000000)
+
+ cmd3 = 'insert into normal_in_ts_float_double_1 values(now,\'2021-01-01 08:00:00.001\',\'-888.00000\',\'66666.000000000\') ;'
tdLog.info(cmd3)
- tdSql.error(cmd3)
- try:
- tdSql.execute(cmd3)
- tdLog.exit("invalid operation: not supported filter condition")
- except Exception as e:
- tdLog.info(repr(e))
- tdLog.info("invalid operation: not supported filter condition")
+ tdSql.execute(cmd3)
+
+ tdSql.query('select * from normal_in_ts_float_double_1 where in_ts in (\'1609459200001\') order by ts desc')
+ tdSql.checkData(0,1,'2021-01-01 08:00:00.001')
+ tdSql.checkData(0,2,-888.00000)
+ tdSql.checkData(0,3,66666.000000000)
+ tdSql.query('select * from normal_in_ts_float_double_1 where in_ts in (\'2021-01-01 08:00:00.001\') order by ts desc')
+ tdSql.checkData(0,1,'2021-01-01 08:00:00.001')
+ tdSql.checkData(0,2,-888.00000)
+ tdSql.checkData(0,3,66666.000000000)
+ tdSql.query('select * from normal_in_ts_float_double_1 where in_float in (-888.00000) order by ts desc')
+ tdSql.checkData(0,1,'2021-01-01 08:00:00.001')
+ tdSql.checkData(0,2,-888.00000)
+ tdSql.checkData(0,3,66666.000000000)
+ tdSql.query('select * from normal_in_ts_float_double_1 where in_double in (66666.000000000) order by ts desc')
+ tdSql.checkData(0,1,'2021-01-01 08:00:00.001')
+ tdSql.checkData(0,2,-888.00000)
+ tdSql.checkData(0,3,66666.000000000)
+
+ cmd4 = '''select * from normal_in_ts_float_double_1
+ where in_ts in (\'1609459200001\',\'2021-01-01 08:00:00.001\',\'1577836800001\',\'2020-01-01 08:00:00.001000\',\'0\',\'1970-01-01 08:00:00.000\')
+ and in_double in (0.000000000,66666.000000000,-88888.000000000)
+ and in_float in (0.00000,666.00000,-888.00000)
+ order by ts desc ;'''
+ tdLog.info(cmd4)
+ tdSql.query(cmd4)
+ tdSql.checkData(0,1,'2021-01-01 08:00:00.001')
+ tdSql.checkData(0,2,-888.00000)
+ tdSql.checkData(0,3,66666.000000000)
+ tdSql.checkData(1,1,'2020-01-01 08:00:00.001')
+ tdSql.checkData(1,2,666.00000)
+ tdSql.checkData(1,3,-88888.000000000)
+ tdSql.checkData(2,1,'1970-01-01 08:00:00.000')
+ tdSql.checkData(2,2,0.00000)
+ tdSql.checkData(2,3,0.000000000)
+
+
def stop(self):
tdSql.close()
diff --git a/tests/pytest/query/nestedQuery/insertData.json b/tests/pytest/query/nestedQuery/insertData.json
new file mode 100644
index 0000000000..d4ef8dbe97
--- /dev/null
+++ b/tests/pytest/query/nestedQuery/insertData.json
@@ -0,0 +1,62 @@
+{
+ "filetype": "insert",
+ "cfgdir": "/etc/taos",
+ "host": "127.0.0.1",
+ "port": 6030,
+ "user": "root",
+ "password": "taosdata",
+ "thread_count": 4,
+ "thread_count_create_tbl": 4,
+ "result_file":"./insert_res.txt",
+ "confirm_parameter_prompt": "no",
+ "insert_interval": 0,
+ "interlace_rows": 10,
+ "num_of_records_per_req": 1000,
+ "max_sql_len": 1024000,
+ "databases": [{
+ "dbinfo": {
+ "name": "db",
+ "drop": "yes",
+ "replica": 1,
+ "days": 10,
+ "cache": 50,
+ "blocks": 8,
+ "precision": "ms",
+ "keep": 365,
+ "minRows": 100,
+ "maxRows": 4096,
+ "comp":2,
+ "walLevel":1,
+ "cachelast":0,
+ "quorum":1,
+ "fsync":3000,
+ "update": 0
+ },
+ "super_tables": [{
+ "name": "stb0",
+ "child_table_exists":"no",
+ "childtable_count": 1,
+ "childtable_prefix": "stb0_",
+ "auto_create_table": "no",
+ "batch_create_tbl_num": 10,
+ "data_source": "rand",
+ "insert_mode": "taosc",
+ "insert_rows": 100000,
+ "childtable_limit": -1,
+ "childtable_offset": 0,
+ "multi_thread_write_one_tbl": "no",
+ "interlace_rows": 0,
+ "insert_interval": 0,
+ "max_sql_len": 1024000,
+ "disorder_ratio": 0,
+ "disorder_range": 1,
+ "timestamp_step": 1000,
+ "start_timestamp": "2020-10-01 00:00:00.000",
+ "sample_format": "csv",
+ "sample_file": "./tools/taosdemoAllTest/sample.csv",
+ "tags_file": "",
+ "columns": [{"type": "INT", "count":1}, {"type": "BINARY", "len": 16, "count":1}, {"type": "BOOL"}],
+ "tags": [{"type": "TINYINT", "count":1}, {"type": "BINARY", "len": 16, "count":1}]
+ }]
+ }]
+}
diff --git a/tests/pytest/query/nestedQuery/nestedQueryJson.py b/tests/pytest/query/nestedQuery/nestedQueryJson.py
new file mode 100644
index 0000000000..36a231a916
--- /dev/null
+++ b/tests/pytest/query/nestedQuery/nestedQueryJson.py
@@ -0,0 +1,81 @@
+###################################################################
+# Copyright (c) 2016 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
+import os
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+ def init(self, conn, logSql):
+ tdLog.debug("start to execute %s" % __file__)
+ tdSql.init(conn.cursor(), logSql)
+
+ def getBuildPath(self):
+ selfPath = os.path.dirname(os.path.realpath(__file__))
+
+ if ("community" in selfPath):
+ projPath = selfPath[:selfPath.find("community")]
+ else:
+ projPath = selfPath[:selfPath.find("tests")]
+
+ for root, dirs, files in os.walk(projPath):
+ if ("taosd" in files):
+ rootRealPath = os.path.dirname(os.path.realpath(root))
+ if ("packaging" not in rootRealPath):
+ buildPath = root[:len(root)-len("/build/bin")]
+ break
+ return buildPath
+
+ def run(self):
+ buildPath = self.getBuildPath()
+ if (buildPath == ""):
+ tdLog.exit("taosd not found!")
+ else:
+ tdLog.info("taosd found in %s" % buildPath)
+ binPath = buildPath+ "/build/bin/"
+
+ # insert: create one or mutiple tables per sql and insert multiple rows per sql
+ os.system("%staosdemo -f query/nestedQuery/insertData.json -y " % binPath)
+ tdSql.execute("use db")
+ tdSql.query("select count (tbname) from stb0")
+ tdSql.checkData(0, 0, 1000)
+ tdSql.query("select count (tbname) from stb1")
+ tdSql.checkData(0, 0, 1000)
+ tdSql.query("select count(*) from stb00_0")
+ tdSql.checkData(0, 0, 100)
+ tdSql.query("select count(*) from stb0")
+ tdSql.checkData(0, 0, 100000)
+ tdSql.query("select count(*) from stb01_1")
+ tdSql.checkData(0, 0, 200)
+ tdSql.query("select count(*) from stb1")
+ tdSql.checkData(0, 0, 200000)
+
+
+
+ testcaseFilename = os.path.split(__file__)[-1]
+ os.system("rm -rf ./insert_res.txt")
+ os.system("rm -rf query/nestedQuery/%s.sql" % testcaseFilename )
+
+
+
+ def stop(self):
+ tdSql.close()
+ tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())
diff --git a/tests/pytest/query/nestedQuery/queryInterval.py b/tests/pytest/query/nestedQuery/queryInterval.py
new file mode 100644
index 0000000000..11c42c463e
--- /dev/null
+++ b/tests/pytest/query/nestedQuery/queryInterval.py
@@ -0,0 +1,106 @@
+###################################################################
+# Copyright (c) 2016 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
+import os
+import taos
+from util.log import tdLog
+from util.cases import tdCases
+from util.sql import tdSql
+from util.dnodes import tdDnodes
+import random
+
+class TDTestCase:
+ def init(self, conn, logSql):
+ tdLog.debug("start to execute %s" % __file__)
+ tdSql.init(conn.cursor(), logSql)
+
+ self.ts1 = 1593548685000
+ self.ts2 = 1593548785000
+
+
+ def run(self):
+ # tdSql.execute("drop database db ")
+ tdSql.prepare()
+ tdSql.execute("create table st (ts timestamp, num int, value int , t_instance int) tags (loc nchar(30))")
+ node = 5
+ number = 10
+ for n in range(node):
+ for m in range(number):
+ dt= m*300000+n*60000 # collecting'frequency is 10s
+ args1=(n,n,self.ts1+dt,n,100+2*m+2*n,10+m+n)
+ # args2=(n,self.ts2+dt,n,120+n,15+n)
+ tdSql.execute("insert into t%d using st tags('beijing%d') values(%d, %d, %d, %d)" % args1)
+ # tdSql.execute("insert into t1 using st tags('shanghai') values(%d, %d, %d, %d)" % args2)
+
+ # interval function
+ tdSql.query("select avg(value) from st interval(10m)")
+ # print(tdSql.queryResult)
+ tdSql.checkRows(6)
+ tdSql.checkData(0, 0, "2020-07-01 04:20:00")
+ tdSql.checkData(1, 1, 107.4)
+
+ # subquery with interval
+ tdSql.query("select avg(avg_val) from(select avg(value) as avg_val from st where loc='beijing0' interval(10m));")
+ tdSql.checkData(0, 0, 109.0)
+
+ # subquery with interval and select two Column in parent query
+ tdSql.error("select ts,avg(avg_val) from(select avg(value) as avg_val from st where loc='beijing0' interval(10m));")
+
+ # subquery with interval and sliding
+ tdSql.query("select avg(value) as avg_val from st where loc='beijing0' interval(8m) sliding(30s) limit 1;")
+ tdSql.checkData(0, 0, "2020-07-01 04:17:00")
+ tdSql.checkData(0, 1, 100)
+ tdSql.query("select avg(avg_val) from(select avg(value) as avg_val from st where loc='beijing1' interval(8m) sliding(30s));")
+ tdSql.checkData(0, 0, 111)
+
+ # subquery with interval and offset
+ tdSql.query("select avg(value) as avg_val from st where loc='beijing0' interval(5m,1m);")
+ tdSql.checkData(0, 0, "2020-07-01 04:21:00")
+ tdSql.checkData(0, 1, 100)
+ tdSql.query("select avg(avg_val) from(select avg(value) as avg_val from st where loc='beijing0' interval(5m,1m) group by loc);")
+ tdSql.checkData(0, 0, 109)
+
+ # subquery with interval,sliding and group by ; parent query with interval
+ tdSql.query("select avg(value) as avg_val from st where loc='beijing0' interval(8m) sliding(1m) group by loc limit 1 offset 52 ;")
+ tdSql.checkData(0, 0, "2020-07-01 05:09:00")
+ tdSql.checkData(0, 1, 118)
+ tdSql.query("select avg(avg_val) as ncst from(select avg(value) as avg_val from st where loc!='beijing0' interval(8m) sliding(1m) group by loc ) interval(5m);")
+ tdSql.checkData(1, 1, 105)
+
+ # # subquery and parent query with interval and sliding
+ tdSql.query("select avg(avg_val) from(select avg(value) as avg_val from st where loc='beijing1' interval(8m) sliding(5m)) interval(10m) sliding(2m);")
+ tdSql.checkData(29, 0, "2020-07-01 05:10:00.000")
+
+ # subquery and parent query with top and bottom
+ tdSql.query("select top(avg_val,2) from(select avg(value) as avg_val,num from st where loc!='beijing0' group by num) order by avg_val desc;")
+ tdSql.checkData(0, 1, 117)
+ tdSql.query("select bottom(avg_val,3) from(select avg(value) as avg_val,num from st where loc!='beijing0' group by num) order by avg_val asc;")
+ tdSql.checkData(0, 1, 111)
+
+ #
+ tdSql.query("select top(avg_val,2) from(select avg(value) as avg_val from st where loc='beijing1' interval(8m) sliding(3m));")
+ tdSql.checkData(0, 1, 120)
+
+ # clear env
+ testcaseFilename = os.path.split(__file__)[-1]
+ os.system("rm -rf ./insert_res.txt")
+ os.system("rm -rf wal/%s.sql" % testcaseFilename )
+
+ def stop(self):
+ tdSql.close()
+ tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())
diff --git a/tests/pytest/query/queryStateWindow.py b/tests/pytest/query/queryStateWindow.py
new file mode 100644
index 0000000000..251dbef658
--- /dev/null
+++ b/tests/pytest/query/queryStateWindow.py
@@ -0,0 +1,111 @@
+###################################################################
+# Copyright (c) 2016 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
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+import numpy as np
+
+
+class TDTestCase:
+ def init(self, conn, logSql):
+ tdLog.debug("start to execute %s" % __file__)
+ tdSql.init(conn.cursor())
+ self.rowNum = 100000
+ self.ts = 1537146000000
+
+ def run(self):
+ tdSql.prepare()
+
+ print("==============step1")
+ tdSql.execute(
+ "create table if not exists st (ts timestamp, t1 int, t2 timestamp, t3 bigint, t4 float, t5 double, t6 binary(10), t7 smallint, t8 tinyint, t9 bool, t10 nchar(10), t11 int unsigned, t12 bigint unsigned, t13 smallint unsigned, t14 tinyint unsigned ,t15 int) tags(dev nchar(50), tag2 binary(16))")
+ tdSql.execute(
+ 'CREATE TABLE if not exists dev_001 using st tags("dev_01", "tag_01")')
+ tdSql.execute(
+ 'CREATE TABLE if not exists dev_002 using st tags("dev_02", "tag_02")')
+
+ print("==============step2")
+
+ tdSql.execute(
+ "INSERT INTO dev_001 VALUES('2020-05-13 10:00:00.000', 1, '2020-05-13 10:00:00.000', 10, 3.1, 3.14, 'test', -10, -126, true, '测试', 15, 10, 65534, 254, 1)('2020-05-13 10:00:01.000', 1, '2020-05-13 10:00:01.000', 10, 3.1, 3.14, 'test', -10, -126, true, '测试', 15, 10, 65534, 253, 5)('2020-05-13 10:00:02.000', 10, '2020-05-13 10:00:00.000', 11, 3.1, 3.14, 'test', 10, -127, false, '测试', 15, 10, 65534, 253, 10)('2020-05-13 10:00:03.000', 1, '2020-05-13 10:00:00.000', 11, 3.1, 3.14, 'test', -10, -126, true, '测试', 14, 12, 65532, 254, 15)")
+
+ for i in range(self.rowNum):
+ tdSql.execute("insert into dev_002 (ts,t1) values(%d, %d,)" % (self.ts + i, i + 1))
+
+ tdSql.query("select count(ts) from dev_001 state_window(t1)")
+ tdSql.checkRows(3)
+ tdSql.checkData(0, 0, 2)
+ tdSql.query("select count(ts) from dev_001 state_window(t3)")
+ tdSql.checkRows(2)
+ tdSql.checkData(1, 0, 2)
+ tdSql.query("select count(ts) from dev_001 state_window(t7)")
+ tdSql.checkRows(3)
+ tdSql.checkData(1, 0, 1)
+ tdSql.query("select count(ts) from dev_001 state_window(t8)")
+ tdSql.checkRows(3)
+ tdSql.checkData(2, 0, 1)
+ tdSql.query("select count(ts) from dev_001 state_window(t11)")
+ tdSql.checkRows(2)
+ tdSql.checkData(0, 0, 3)
+ tdSql.query("select count(ts) from dev_001 state_window(t12)")
+ tdSql.checkRows(2)
+ tdSql.checkData(1, 0, 1)
+ tdSql.query("select count(ts) from dev_001 state_window(t13)")
+ tdSql.checkRows(2)
+ tdSql.checkData(1, 0, 1)
+ tdSql.query("select count(ts) from dev_001 state_window(t14)")
+ tdSql.checkRows(3)
+ tdSql.checkData(1, 0, 2)
+ tdSql.query("select count(ts) from dev_002 state_window(t1)")
+ tdSql.checkRows(100000)
+
+ # with all aggregate function
+ tdSql.query("select count(*),sum(t1),avg(t1),twa(t1),stddev(t15),leastsquares(t15,1,1),first(t15),last(t15),spread(t15),percentile(t15,90),t9 from dev_001 state_window(t9);")
+ tdSql.checkRows(3)
+ tdSql.checkData(0, 0, 2)
+ tdSql.checkData(1, 1, 10)
+ tdSql.checkData(0, 2, 1)
+ # tdSql.checkData(0, 3, 1)
+ tdSql.checkData(0, 4, np.std([1,5]))
+ # tdSql.checkData(0, 5, 1)
+ tdSql.checkData(0, 6, 1)
+ tdSql.checkData(0, 7, 5)
+ tdSql.checkData(0, 8, 4)
+ tdSql.checkData(0, 9, 4.6)
+ tdSql.checkData(0, 10, 'True')
+
+ # with where
+ tdSql.query("select avg(t15),t9 from dev_001 where t9='true' state_window(t9);")
+ tdSql.checkData(0, 0, 7)
+ tdSql.checkData(0, 1, 'True')
+
+ # error
+ tdSql.error("select count(*) from dev_001 state_window(t2)")
+ tdSql.error("select count(*) from st state_window(t3)")
+ tdSql.error("select count(*) from dev_001 state_window(t4)")
+ tdSql.error("select count(*) from dev_001 state_window(t5)")
+ tdSql.error("select count(*) from dev_001 state_window(t6)")
+ tdSql.error("select count(*) from dev_001 state_window(t10)")
+ tdSql.error("select count(*) from dev_001 state_window(tag2)")
+
+
+ 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/taosdumpTest.py b/tests/pytest/tools/taosdumpTest.py
index 534a477b34..8746f4ecdf 100644
--- a/tests/pytest/tools/taosdumpTest.py
+++ b/tests/pytest/tools/taosdumpTest.py
@@ -45,7 +45,9 @@ class TDTestCase:
for i in range(100):
sql += "(%d, %d, 'nchar%d')" % (currts + i, i % 100, i % 100)
tdSql.execute(sql)
+
+ os.system("rm /tmp/*.sql")
os.system("taosdump --databases db -o /tmp")
tdSql.execute("drop database db")
diff --git a/tests/pytest/tools/taosdumpTest2.py b/tests/pytest/tools/taosdumpTest2.py
new file mode 100644
index 0000000000..51a73555a8
--- /dev/null
+++ b/tests/pytest/tools/taosdumpTest2.py
@@ -0,0 +1,74 @@
+###################################################################
+# Copyright (c) 2016 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
+import os
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+ def init(self, conn, logSql):
+ tdLog.debug("start to execute %s" % __file__)
+ tdSql.init(conn.cursor(), logSql)
+
+ self.ts = 1601481600000
+ self.numberOfTables = 1
+ self.numberOfRecords = 15000
+
+ def run(self):
+ tdSql.prepare()
+
+ tdSql.execute("create table st(ts timestamp, c1 timestamp, c2 int, c3 bigint, c4 float, c5 double, c6 binary(8), c7 smallint, c8 tinyint, c9 bool, c10 nchar(8)) tags(t1 int)")
+ tdSql.execute("create table t1 using st tags(0)")
+ currts = self.ts
+ finish = 0
+ while(finish < self.numberOfRecords):
+ sql = "insert into t1 values"
+ for i in range(finish, self.numberOfRecords):
+ sql += "(%d, 1019774612, 29931, 1442173978, 165092.468750, 1128.643179, 'MOCq1pTu', 18405, 82, 0, 'g0A6S0Fu')" % (currts + i)
+ finish = i + 1
+ if (1048576 - len(sql)) < 16384:
+ break
+ tdSql.execute(sql)
+
+ os.system("rm /tmp/*.sql")
+ os.system("taosdump --databases db -o /tmp -B 32766 -L 1048576")
+
+ tdSql.execute("drop database db")
+ tdSql.query("show databases")
+ tdSql.checkRows(0)
+
+ os.system("taosdump -i /tmp")
+
+ tdSql.query("show databases")
+ tdSql.checkRows(1)
+ tdSql.checkData(0, 0, 'db')
+
+ tdSql.execute("use db")
+ tdSql.query("show stables")
+ tdSql.checkRows(1)
+ tdSql.checkData(0, 0, 'st')
+
+ tdSql.query("select count(*) from t1")
+ tdSql.checkData(0, 0, self.numberOfRecords)
+
+ def stop(self):
+ tdSql.close()
+ tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())
\ No newline at end of file
diff --git a/tests/pytest/util/taosdemoCfg.py b/tests/pytest/util/taosdemoCfg.py
new file mode 100644
index 0000000000..5071e915a5
--- /dev/null
+++ b/tests/pytest/util/taosdemoCfg.py
@@ -0,0 +1,450 @@
+###################################################################
+# Copyright (c) 2016 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
+import os
+import time
+import datetime
+import inspect
+import psutil
+import shutil
+import json
+from util.log import *
+from multiprocessing import cpu_count
+
+
+# TODO: fully test the function. Handle exceptions.
+# Handle json format not accepted by taosdemo
+class TDTaosdemoCfg:
+ def __init__(self):
+ self.insert_cfg = {
+ "filetype": "insert",
+ "cfgdir": "/etc/taos",
+ "host": "127.0.0.1",
+ "port": 6030,
+ "user": "root",
+ "password": "taosdata",
+ "thread_count": cpu_count(),
+ "thread_count_create_tbl": cpu_count(),
+ "result_file": "./insert_res.txt",
+ "confirm_parameter_prompt": "no",
+ "insert_interval": 0,
+ "num_of_records_per_req": 32766,
+ "max_sql_len": 32766,
+ "databases": None
+ }
+
+ self.db = {
+ "name": 'db',
+ "drop": 'yes',
+ "replica": 1,
+ "days": 10,
+ "cache": 16,
+ "blocks": 6,
+ "precision": "ms",
+ "keep": 3650,
+ "minRows": 100,
+ "maxRows": 4096,
+ "comp": 2,
+ "walLevel": 1,
+ "cachelast": 0,
+ "quorum": 1,
+ "fsync": 3000,
+ "update": 0
+ }
+
+ self.query_cfg = {
+ "filetype": "query",
+ "cfgdir": "/etc/taos",
+ "host": "127.0.0.1",
+ "port": 6030,
+ "user": "root",
+ "password": "taosdata",
+ "confirm_parameter_prompt": "no",
+ "databases": "db",
+ "query_times": 2,
+ "query_mode": "taosc",
+ "specified_table_query": None,
+ "super_table_query": None
+ }
+
+ self.table_query = {
+ "query_interval": 1,
+ "concurrent": 3,
+ "sqls": None
+ }
+
+ self.stable_query = {
+ "stblname": "stb",
+ "query_interval": 1,
+ "threads": 3,
+ "sqls": None
+ }
+
+ self.sub_cfg = {
+ "filetype": "subscribe",
+ "cfgdir": "/etc/taos",
+ "host": "127.0.0.1",
+ "port": 6030,
+ "user": "root",
+ "password": "taosdata",
+ "databases": "db",
+ "confirm_parameter_prompt": "no",
+ "specified_table_query": None,
+ "super_table_query": None
+ }
+
+ self.table_sub = {
+ "concurrent": 1,
+ "mode": "sync",
+ "interval": 10000,
+ "restart": "yes",
+ "keepProgress": "yes",
+ "sqls": None
+ }
+
+ self.stable_sub = {
+ "stblname": "stb",
+ "threads": 1,
+ "mode": "sync",
+ "interval": 10000,
+ "restart": "yes",
+ "keepProgress": "yes",
+ "sqls": None
+ }
+
+ self.stbs = []
+ self.stb_template = {
+ "name": "stb",
+ "child_table_exists": "no",
+ "childtable_count": 100,
+ "childtable_prefix": "stb_",
+ "auto_create_table": "no",
+ "batch_create_tbl_num": 5,
+ "data_source": "rand",
+ "insert_mode": "taosc",
+ "insert_rows": 100,
+ "childtable_limit": 10,
+ "childtable_offset": 0,
+ "interlace_rows": 0,
+ "insert_interval": 0,
+ "max_sql_len": 32766,
+ "disorder_ratio": 0,
+ "disorder_range": 1000,
+ "timestamp_step": 1,
+ "start_timestamp": "2020-10-01 00:00:00.000",
+ "sample_format": "csv",
+ "sample_file": "./sample.csv",
+ "tags_file": "",
+ "columns": [{"type": "INT", "count": 1}],
+ "tags": [{"type": "BIGINT", "count": 1}]
+ }
+
+ self.tb_query_sql = []
+ self.tb_query_sql_template = {
+ "sql": "select last_row(*) from stb_0 ",
+ "result": "temp/query_res0.txt"
+ }
+
+ self.stb_query_sql = []
+ self.stb_query_sql_template = {
+ "sql": "select last_row(ts) from xxxx",
+ "result": "temp/query_res2.txt"
+ }
+
+ self.tb_sub_sql = []
+ self.tb_sub_sql_template = {
+ "sql": "select * from stb_0 ;",
+ "result": "temp/subscribe_res0.txt"
+ }
+
+ self.stb_sub_sql = []
+ self.stb_sub_sql_template = {
+ "sql": "select * from xxxx where ts > '2021-02-25 11:35:00.000' ;",
+ "result": "temp/subscribe_res1.txt"
+ }
+
+ # The following functions are import functions for different dicts and lists
+ # except import_sql, all other import functions will a dict and overwrite the origional dict
+ # dict_in: the dict used to overwrite the target
+ def import_insert_cfg(self, dict_in):
+ self.insert_cfg = dict_in
+
+ def import_db(self, dict_in):
+ self.db = dict_in
+
+ def import_stbs(self, dict_in):
+ self.stbs = dict_in
+
+ def import_query_cfg(self, dict_in):
+ self.query_cfg = dict_in
+
+ def import_table_query(self, dict_in):
+ self.table_query = dict_in
+
+ def import_stable_query(self, dict_in):
+ self.stable_query = dict_in
+
+ def import_sub_cfg(self, dict_in):
+ self.sub_cfg = dict_in
+
+ def import_table_sub(self, dict_in):
+ self.table_sub = dict_in
+
+ def import_stable_sub(self, dict_in):
+ self.stable_sub = dict_in
+
+ def import_sql(self, Sql_in, mode):
+ """used for importing the sql later used
+
+ Args:
+ Sql_in (dict): the imported sql dict
+ mode (str): the sql storing location within TDTaosdemoCfg
+ format: 'fileType_tableType'
+ fileType: query, sub
+ tableType: table, stable
+ """
+ if mode == 'query_table':
+ self.tb_query_sql = Sql_in
+ elif mode == 'query_stable':
+ self.stb_query_sql = Sql_in
+ elif mode == 'sub_table':
+ self.tb_sub_sql = Sql_in
+ elif mode == 'sub_stable':
+ self.stb_sub_sql = Sql_in
+ # import functions end
+
+ # The following functions are alter functions for different dicts
+ # Args:
+ # key: the key that is going to be modified
+ # value: the value of the key that is going to be modified
+ # if key = 'databases' | "specified_table_query" | "super_table_query"|"sqls"
+ # value will not be used
+
+ def alter_insert_cfg(self, key, value):
+
+ if key == 'databases':
+ self.insert_cfg[key] = [
+ {
+ 'dbinfo': self.db,
+ 'super_tables': self.stbs
+ }
+ ]
+ else:
+ self.insert_cfg[key] = value
+
+ def alter_db(self, key, value):
+ self.db[key] = value
+
+ def alter_query_tb(self, key, value):
+ if key == "sqls":
+ self.table_query[key] = self.tb_query_sql
+ else:
+ self.table_query[key] = value
+
+ def alter_query_stb(self, key, value):
+ if key == "sqls":
+ self.stable_query[key] = self.stb_query_sql
+ else:
+ self.stable_query[key] = value
+
+ def alter_query_cfg(self, key, value):
+ if key == "specified_table_query":
+ self.query_cfg["specified_table_query"] = self.table_query
+ elif key == "super_table_query":
+ self.query_cfg["super_table_query"] = self.stable_query
+ else:
+ self.table_query[key] = value
+
+ def alter_sub_cfg(self, key, value):
+ if key == "specified_table_query":
+ self.sub_cfg["specified_table_query"] = self.table_sub
+ elif key == "super_table_query":
+ self.sub_cfg["super_table_query"] = self.stable_sub
+ else:
+ self.table_query[key] = value
+
+ def alter_sub_stb(self, key, value):
+ if key == "sqls":
+ self.stable_sub[key] = self.stb_sub_sql
+ else:
+ self.stable_sub[key] = value
+
+ def alter_sub_tb(self, key, value):
+ if key == "sqls":
+ self.table_sub[key] = self.tb_sub_sql
+ else:
+ self.table_sub[key] = value
+ # alter function ends
+
+ # the following functions are for handling the sql lists
+ def append_sql_stb(self, target, value):
+ """for appending sql dict into specific sql list
+
+ Args:
+ target (str): the target append list
+ format: 'fileType_tableType'
+ fileType: query, sub
+ tableType: table, stable
+ unique: 'insert_stbs'
+ value (dict): the sql dict going to be appended
+ """
+ if target == 'insert_stbs':
+ self.stbs.append(value)
+ elif target == 'query_table':
+ self.tb_query_sql.append(value)
+ elif target == 'query_stable':
+ self.stb_query_sql.append(value)
+ elif target == 'sub_table':
+ self.tb_sub_sql.append(value)
+ elif target == 'sub_stable':
+ self.stb_sub_sql.append(value)
+
+ def pop_sql_stb(self, target, index):
+ """for poping a sql dict from specific sql list
+
+ Args:
+ target (str): the target append list
+ format: 'fileType_tableType'
+ fileType: query, sub
+ tableType: table, stable
+ unique: 'insert_stbs'
+ index (int): the sql dict that is going to be popped
+ """
+ if target == 'insert_stbs':
+ self.stbs.pop(index)
+ elif target == 'query_table':
+ self.tb_query_sql.pop(index)
+ elif target == 'query_stable':
+ self.stb_query_sql.pop(index)
+ elif target == 'sub_table':
+ self.tb_sub_sql.pop(index)
+ elif target == 'sub_stable':
+ self.stb_sub_sql.pop(index)
+ # sql list modification function end
+
+ # The following functions are get functions for different dicts
+ def get_db(self):
+ return self.db
+
+ def get_stb(self):
+ return self.stbs
+
+ def get_insert_cfg(self):
+ return self.insert_cfg
+
+ def get_query_cfg(self):
+ return self.query_cfg
+
+ def get_tb_query(self):
+ return self.table_query
+
+ def get_stb_query(self):
+ return self.stable_query
+
+ def get_sub_cfg(self):
+ return self.sub_cfg
+
+ def get_tb_sub(self):
+ return self.table_sub
+
+ def get_stb_sub(self):
+ return self.stable_sub
+
+ def get_sql(self, target):
+ """general get function for all sql lists
+
+ Args:
+ target (str): the sql list want to get
+ format: 'fileType_tableType'
+ fileType: query, sub
+ tableType: table, stable
+ unique: 'insert_stbs'
+ """
+ if target == 'query_table':
+ return self.tb_query_sql
+ elif target == 'query_stable':
+ return self.stb_query_sql
+ elif target == 'sub_table':
+ return self.tb_sub_sql
+ elif target == 'sub_stable':
+ return self.stb_sub_sql
+
+ def get_template(self, target):
+ """general get function for the default sql template
+
+ Args:
+ target (str): the sql list want to get
+ format: 'fileType_tableType'
+ fileType: query, sub
+ tableType: table, stable
+ unique: 'insert_stbs'
+ """
+ if target == 'insert_stbs':
+ return self.stb_template
+ elif target == 'query_table':
+ return self.tb_query_sql_template
+ elif target == 'query_stable':
+ return self.stb_query_sql_template
+ elif target == 'sub_table':
+ return self.tb_sub_sql_template
+ elif target == 'sub_stable':
+ return self.stb_sub_sql_template
+ else:
+ print(f'did not find {target}')
+
+ # the folloing are the file generation functions
+ """defalut document:
+ generator functio for generating taosdemo json file
+ will assemble the dicts and dump the final json
+
+ Args:
+ pathName (str): the directory wanting the json file to be
+ fileName (str): the name suffix of the json file
+ Returns:
+ str: [pathName]/[filetype]_[filName].json
+ """
+
+ def generate_insert_cfg(self, pathName, fileName):
+ cfgFileName = f'{pathName}/insert_{fileName}.json'
+ self.alter_insert_cfg('databases', None)
+ with open(cfgFileName, 'w') as file:
+ json.dump(self.insert_cfg, file)
+ return cfgFileName
+
+ def generate_query_cfg(self, pathName, fileName):
+ cfgFileName = f'{pathName}/query_{fileName}.json'
+ self.alter_query_tb('sqls', None)
+ self.alter_query_stb('sqls', None)
+ self.alter_query_cfg('specified_table_query', None)
+ self.alter_query_cfg('super_table_query', None)
+ with open(cfgFileName, 'w') as file:
+ json.dump(self.query_cfg, file)
+ return cfgFileName
+
+ def generate_subscribe_cfg(self, pathName, fileName):
+ cfgFileName = f'{pathName}/subscribe_{fileName}.json'
+ self.alter_sub_tb('sqls', None)
+ self.alter_sub_stb('sqls', None)
+ self.alter_sub_cfg('specified_table_query', None)
+ self.alter_sub_cfg('super_table_query', None)
+ with open(cfgFileName, 'w') as file:
+ json.dump(self.sub_cfg, file)
+ return cfgFileName
+ # file generation functions ends
+
+ def drop_cfg_file(self, fileName):
+ os.remove(f'{fileName}')
+
+
+taosdemoCfg = TDTaosdemoCfg()
diff --git a/tests/script/general/parser/gendata.sh b/tests/script/general/parser/gendata.sh
index f56fdc3468..b2074147ca 100755
--- a/tests/script/general/parser/gendata.sh
+++ b/tests/script/general/parser/gendata.sh
@@ -4,3 +4,5 @@ Cur_Dir=$(pwd)
echo $Cur_Dir
echo "'2020-1-1 1:1:1','abc','device',123,'9876', 'abc', 'net', 'mno', 'province', 'city', 'al'" >> ~/data.sql
+echo "'2020-1-2 1:1:1','abc','device',123,'9876', 'abc', 'net', 'mno', 'province', 'city', 'al'" >> ~/data.sql
+echo "'2020-1-3 1:1:1','abc','device',123,'9876', 'abc', 'net', 'mno', 'province', 'city', 'al'" >> ~/data.sql
diff --git a/tests/script/general/parser/groupby.sim b/tests/script/general/parser/groupby.sim
index 124e76e85c..6ae5d420d8 100644
--- a/tests/script/general/parser/groupby.sim
+++ b/tests/script/general/parser/groupby.sim
@@ -654,53 +654,131 @@ if $data31 != @20-03-27 05:10:19.000@ then
return -1
endi
-#sql select irate(c) from st where t1="1" and ts >= '2020-03-27 04:11:17.732' and ts < '2020-03-27 05:11:17.732' interval(1m) sliding(15s) group by tbname,t1,t2;
-#if $rows != 40 then
-# return -1
-#endi
-#
-#if $data01 != 1.000000000 then
-# return -1
-#endi
-#if $data02 != t1 then
-# return -1
-#endi
-#if $data03 != 1 then
-# return -1
-#endi
-#if $data04 != 1 then
-# return -1
-#endi
-#
-#if $data11 != 1.000000000 then
-# return -1
-#endi
-#if $data12 != t1 then
-# return -1
-#endi
-#if $data13 != 1 then
-# return -1
-#endi
-#if $data14 != 1 then
-# return -1
-#endi
-#
-#sql select irate(c) from st where t1="1" and ts >= '2020-03-27 04:11:17.732' and ts < '2020-03-27 05:11:17.732' interval(1m) sliding(15s) group by tbname,t1,t2 limit 1;
-#if $rows != 2 then
-# return -1
-#endi
-#
-#if $data11 != 1.000000000 then
-# return -1
-#endi
-#if $data12 != t2 then
-# return -1
-#endi
-#if $data13 != 1 then
-# return -1
-#endi
-#if $data14 != 2 then
-# return -1
-#endi
+print ===============>
+sql select stddev(c),c from st where t2=1 or t2=2 group by c;
+if $rows != 4 then
+ return -1
+endi
+
+if $data00 != 0.000000000 then
+ return -1
+endi
+
+if $data01 != 1 then
+ return -1
+endi
+
+if $data10 != 0.000000000 then
+ return -1
+endi
+
+if $data11 != 2 then
+ return -1
+endi
+
+if $data20 != 0.000000000 then
+ return -1
+endi
+
+if $data21 != 3 then
+ return -1
+endi
+
+if $data30 != 0.000000000 then
+ return -1
+endi
+
+if $data31 != 4 then
+ return -1
+endi
+
+sql select irate(c) from st where t1="1" and ts >= '2020-03-27 04:11:17.732' and ts < '2020-03-27 05:11:17.732' interval(1m) sliding(15s) group by tbname,t1,t2;
+if $rows != 40 then
+ return -1
+endi
+
+if $data01 != 1.000000000 then
+ return -1
+endi
+if $data02 != t1 then
+ return -1
+endi
+if $data03 != 1 then
+ return -1
+endi
+if $data04 != 1 then
+ return -1
+endi
+
+if $data11 != 1.000000000 then
+ return -1
+endi
+if $data12 != t1 then
+ return -1
+endi
+if $data13 != 1 then
+ return -1
+endi
+if $data14 != 1 then
+ return -1
+endi
+
+sql select irate(c) from st where t1="1" and ts >= '2020-03-27 04:11:17.732' and ts < '2020-03-27 05:11:17.732' interval(1m) sliding(15s) group by tbname,t1,t2 limit 1;
+if $rows != 2 then
+ return -1
+endi
+
+if $data11 != 1.000000000 then
+ return -1
+endi
+if $data12 != t2 then
+ return -1
+endi
+if $data13 != 1 then
+ return -1
+endi
+if $data14 != 2 then
+ return -1
+endi
+
+sql create table m1 (ts timestamp, k int, f1 int) tags(a int);
+sql create table tm0 using m1 tags(0);
+sql create table tm1 using m1 tags(1);
+
+sql insert into tm0 values('2020-1-1 1:1:1', 1, 10);
+sql insert into tm0 values('2020-1-1 1:1:2', 1, 20);
+sql insert into tm1 values('2020-2-1 1:1:1', 2, 10);
+sql insert into tm1 values('2020-2-1 1:1:2', 2, 20);
+
+system sh/exec.sh -n dnode1 -s stop -x SIGINT
+sleep 100
+system sh/exec.sh -n dnode1 -s start
+sleep 100
+
+sql connect
+sleep 100
+sql use group_db0;
+
+print =========================>TD-4894
+sql select count(*),k from m1 group by k;
+if $rows != 2 then
+ return -1
+endi
+
+if $data00 != 2 then
+ return -1
+endi
+
+if $data01 != 1 then
+ return -1
+endi
+
+if $data10 != 2 then
+ return -1
+endi
+
+if $data11 != 2 then
+ return -1
+endi
system sh/exec.sh -n dnode1 -s stop -x SIGINT
diff --git a/tests/script/general/parser/having.sim b/tests/script/general/parser/having.sim
index ddafdd7329..a8d2102bef 100644
--- a/tests/script/general/parser/having.sim
+++ b/tests/script/general/parser/having.sim
@@ -1,6 +1,6 @@
system sh/stop_dnodes.sh
system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2
system sh/exec.sh -n dnode1 -s start
diff --git a/tests/script/general/parser/import_file.sim b/tests/script/general/parser/import_file.sim
index e9f0f1ed08..cf11194ba7 100644
--- a/tests/script/general/parser/import_file.sim
+++ b/tests/script/general/parser/import_file.sim
@@ -15,6 +15,8 @@ $inFileName = '~/data.csv'
$numOfRows = 10000
system general/parser/gendata.sh
+sql create table stbx (ts TIMESTAMP, collect_area NCHAR(12), device_id BINARY(16), imsi BINARY(16), imei BINARY(16), mdn BINARY(10), net_type BINARY(4), mno NCHAR(4), province NCHAR(10), city NCHAR(16), alarm BINARY(2)) tags(a int, b binary(12));
+
sql create table tbx (ts TIMESTAMP, collect_area NCHAR(12), device_id BINARY(16), imsi BINARY(16), imei BINARY(16), mdn BINARY(10), net_type BINARY(4), mno NCHAR(4), province NCHAR(10), city NCHAR(16), alarm BINARY(2))
print ====== create tables success, starting import data
@@ -23,13 +25,48 @@ sql import into tbx file '~/data.sql'
sql select count(*) from tbx
if $rows != 1 then
+ print expect 1, actual: $rows
return -1
endi
-#if $data00 != $numOfRows then
-# print "expect: $numOfRows, act: $data00"
-# return -1
-#endi
+if $data00 != 3 then
+ return -1
+endi
+
+sql drop table tbx;
+
+sql insert into tbx using stbx tags(1,'abc') file '~/data.sql';
+sql insert into tbx using stbx tags(1,'abc') file '~/data.sql';
+
+sql select count(*) from tbx
+if $rows != 1 then
+ return -1
+endi
+
+if $data00 != 3 then
+ return -1
+endi
+
+sql drop table tbx;
+sql insert into tbx using stbx(b) tags('abcf') file '~/data.sql';
+
+sql select ts,a,b from tbx;
+if $rows != 3 then
+ return -1
+endi
+
+if $data00 != @20-01-01 01:01:01.000@ then
+ print expect 20-01-01 01:01:01.000 , actual: $data00
+ return -1
+endi
+
+if $data01 != NULL then
+ return -1
+endi
+
+if $data02 != @abcf@ then
+ return -1
+endi
system rm -f ~/data.sql
diff --git a/tests/script/general/parser/nestquery.sim b/tests/script/general/parser/nestquery.sim
index 8249d9197f..fd56a91dd6 100644
--- a/tests/script/general/parser/nestquery.sim
+++ b/tests/script/general/parser/nestquery.sim
@@ -180,20 +180,82 @@ if $data21 != 49.500000000 then
endi
#define TSDB_FUNC_APERCT 7
-#define TSDB_FUNC_LAST_ROW 10
#define TSDB_FUNC_TWA 14
#define TSDB_FUNC_LEASTSQR 15
-#define TSDB_FUNC_ARITHM 23
#define TSDB_FUNC_DIFF 24
#define TSDB_FUNC_INTERP 28
-#define TSDB_FUNC_RATE 29
#define TSDB_FUNC_IRATE 30
#define TSDB_FUNC_DERIVATIVE 32
sql_error select stddev(c1) from (select c1 from nest_tb0);
sql_error select percentile(c1, 20) from (select * from nest_tb0);
+sql_error select interp(c1) from (select * from nest_tb0);
+sql_error select derivative(val, 1s, 0) from (select c1 val from nest_tb0);
+sql_error select twa(c1) from (select c1 from nest_tb0);
+sql_error select irate(c1) from (select c1 from nest_tb0);
+sql_error select diff(c1), twa(c1) from (select * from nest_tb0);
+sql_error select irate(c1), interp(c1), twa(c1) from (select * from nest_tb0);
+
+sql select apercentile(c1, 50) from (select * from nest_tb0) interval(1d)
+sql select twa(c1) from (select * from nest_tb0);
+sql select leastsquares(c1, 1, 1) from (select * from nest_tb0);
+sql select irate(c1) from (select * from nest_tb0);
sql select avg(c1),sum(c2), max(c3), min(c4), count(*), first(c7), last(c7),spread(c6) from (select * from nest_tb0) interval(1d);
+if $rows != 7 then
+ return -1
+endi
+
+if $data00 != @20-09-15 00:00:00.000@ then
+ return -1
+endi
+
+if $data01 != 48.666666667 then
+ print expect 48.666666667, actual: $data01
+ return -1
+endi
+
+if $data02 != 70080.000000000 then
+ return -1
+endi
+
+if $data03 != 99 then
+ return -1
+endi
+
+if $data04 != 0 then
+ return -1
+endi
+
+if $data05 != 1440 then
+ return -1
+endi
+
+if $data06 != 0 then
+ print $data06
+ return -1
+endi
+
+if $data07 != 1 then
+ return -1
+endi
+
+if $data08 != 99.000000000 then
+ print expect 99.000000000, actual: $data08
+ return -1
+endi
+
+if $data10 != @20-09-16 00:00:00.000@ then
+ return -1
+endi
+
+if $data11 != 49.777777778 then
+ return -1
+endi
+
+if $data12 != 71680.000000000 then
+ return -1
+endi
sql select top(x, 20) from (select c1 x from nest_tb0);
@@ -207,6 +269,9 @@ print ===================> group by + having
+print =========================> ascending order/descending order
+
+
print =========================> nest query join
@@ -273,7 +338,6 @@ if $data03 != @20-09-15 00:00:00.000@ then
return -1
endi
-sql_error select derivative(val, 1s, 0) from (select c1 val from nest_tb0);
sql select diff(val) from (select c1 val from nest_tb0);
if $rows != 9999 then
return -1
diff --git a/tests/script/general/parser/select_with_tags.sim b/tests/script/general/parser/select_with_tags.sim
index 45f6f5c49f..f5c94d2ae6 100644
--- a/tests/script/general/parser/select_with_tags.sim
+++ b/tests/script/general/parser/select_with_tags.sim
@@ -68,6 +68,27 @@ endw
sleep 100
+
+#======================= only check first table tag, TD-4827
+sql select count(*) from $mt where t1 in (0)
+if $rows != 1 then
+ return -1
+endi
+if $data00 != $rowNum then
+ return -1;
+endi
+
+$secTag = ' . abc
+$secTag = $secTag . 0
+$secTag = $secTag . '
+sql select count(*) from $mt where t2 =$secTag and t1 in (0)
+if $rows != 1 then
+ return -1
+endi
+if $data00 != $rowNum then
+ return -1;
+endi
+
#================================
sql select ts from select_tags_mt0
print $rows
diff --git a/tests/script/general/parser/testSuite.sim b/tests/script/general/parser/testSuite.sim
index 545e19edec..5f71138966 100644
--- a/tests/script/general/parser/testSuite.sim
+++ b/tests/script/general/parser/testSuite.sim
@@ -63,4 +63,3 @@ run general/parser/between_and.sim
run general/parser/last_cache.sim
run general/parser/nestquery.sim
run general/parser/precision_ns.sim
-
diff --git a/tests/script/general/parser/where.sim b/tests/script/general/parser/where.sim
index 00a22eede6..d20f013a8e 100644
--- a/tests/script/general/parser/where.sim
+++ b/tests/script/general/parser/where.sim
@@ -139,18 +139,18 @@ sql_error select * from $mt where c1 like 1
sql create table wh_mt1 (ts timestamp, c1 smallint, c2 int, c3 bigint, c4 float, c5 double, c6 tinyint, c7 binary(10), c8 nchar(10), c9 bool, c10 timestamp) tags (t1 binary(10), t2 smallint, t3 int, t4 bigint, t5 float, t6 double)
sql create table wh_mt1_tb1 using wh_mt1 tags ('tb11', 1, 1, 1, 1, 1)
sql insert into wh_mt1_tb1 values (now, 1, 1, 1, 1, 1, 1, 'binary', 'nchar', true, '2019-01-01 00:00:00.000')
-sql_error select last(*) from wh_mt1 where c1 in ('1')
-sql_error select last(*) from wh_mt1_tb1 where c1 in ('1')
-sql_error select last(*) from wh_mt1 where c2 in ('1')
-sql_error select last(*) from wh_mt1_tb1 where c2 in ('1')
-sql_error select last(*) from wh_mt1 where c3 in ('1')
-sql_error select last(*) from wh_mt1_tb1 where c3 in ('1')
-sql_error select last(*) from wh_mt1 where c4 in ('1')
-sql_error select last(*) from wh_mt1_tb1 where c4 in ('1')
-sql_error select last(*) from wh_mt1 where c5 in ('1')
-sql_error select last(*) from wh_mt1_tb1 where c5 in ('1')
-sql_error select last(*) from wh_mt1 where c6 in ('1')
-sql_error select last(*) from wh_mt1_tb1 where c6 in ('1')
+#sql_error select last(*) from wh_mt1 where c1 in ('1')
+#sql_error select last(*) from wh_mt1_tb1 where c1 in ('1')
+#sql_error select last(*) from wh_mt1 where c2 in ('1')
+#sql_error select last(*) from wh_mt1_tb1 where c2 in ('1')
+#sql_error select last(*) from wh_mt1 where c3 in ('1')
+#sql_error select last(*) from wh_mt1_tb1 where c3 in ('1')
+#sql_error select last(*) from wh_mt1 where c4 in ('1')
+#sql_error select last(*) from wh_mt1_tb1 where c4 in ('1')
+#sql_error select last(*) from wh_mt1 where c5 in ('1')
+#sql_error select last(*) from wh_mt1_tb1 where c5 in ('1')
+#sql_error select last(*) from wh_mt1 where c6 in ('1')
+#sql_error select last(*) from wh_mt1_tb1 where c6 in ('1')
#sql_error select last(*) from wh_mt1 where c7 in ('binary')
#sql_error select last(*) from wh_mt1_tb1 where c7 in ('binary')
#sql_error select last(*) from wh_mt1 where c8 in ('nchar')
@@ -352,5 +352,18 @@ if $rows != 0 then
return -1
endi
-
+print ==========================> td-4783
+sql create table where_ts(ts timestamp, f int)
+sql insert into where_ts values('2021-06-19 16:22:00', 1);
+sql insert into where_ts values('2021-06-19 16:23:00', 2);
+sql insert into where_ts values('2021-06-19 16:24:00', 3);
+sql insert into where_ts values('2021-06-19 16:25:00', 1);
+sql select * from (select * from where_ts) where ts<'2021-06-19 16:25:00' and ts>'2021-06-19 16:22:00'
+if $row != 2 then
+ return -1
+endi
+print $data00, $data01
+if $data01 != 2 then
+ return -1
+endi
system sh/exec.sh -n dnode1 -s stop -x SIGINT
diff --git a/tests/tsim/src/simMain.c b/tests/tsim/src/simMain.c
index 6a9d96bc3b..7d74c62c7d 100644
--- a/tests/tsim/src/simMain.c
+++ b/tests/tsim/src/simMain.c
@@ -35,7 +35,7 @@ int32_t main(int32_t argc, char *argv[]) {
for (int32_t i = 1; i < argc; ++i) {
if (strcmp(argv[i], "-c") == 0 && i < argc - 1) {
- tstrncpy(configDir, argv[++i], MAX_FILE_NAME_LEN);
+ tstrncpy(configDir, argv[++i], 128);
} else if (strcmp(argv[i], "-f") == 0 && i < argc - 1) {
strcpy(scriptFile, argv[++i]);
} else if (strcmp(argv[i], "-a") == 0) {
@@ -75,4 +75,4 @@ int32_t main(int32_t argc, char *argv[]) {
simInfo("execute result %d", ret);
return ret;
-}
\ No newline at end of file
+}