Merge branch '3.0' into feat/TD-32642
This commit is contained in:
WANG MINGMING
GitHub
commit
4a3eda51e0
|
|
@ -162,3 +162,4 @@ geos_c.h
|
|||
source/libs/parser/src/sql.c
|
||||
include/common/ttokenauto.h
|
||||
!packaging/smokeTest/pytest_require.txt
|
||||
tdengine-test-dir
|
||||
|
|
|
|||
|
|
@ -164,9 +164,6 @@ If you are using Maven to manage your project, simply add the following dependen
|
|||
pip3 install taospy[ws]
|
||||
```
|
||||
|
||||
</TabItem>
|
||||
</Tabs>
|
||||
|
||||
- **Installation Verification**
|
||||
|
||||
<Tabs defaultValue="rest">
|
||||
|
|
@ -199,8 +196,8 @@ import taosws
|
|||
|
||||
</TabItem>
|
||||
</Tabs>
|
||||
</TabItem>
|
||||
|
||||
<Tabs>
|
||||
<TabItem label="Go" value="go">
|
||||
|
||||
Edit `go.mod` to add the `driver-go` dependency.
|
||||
|
|
|
|||
|
|
@ -194,7 +194,7 @@ alter_table_option: {
|
|||
### Modify Subtable Tag Value
|
||||
|
||||
```sql
|
||||
ALTER TABLE tb_name SET tag tag_name=new_tag_value;
|
||||
ALTER TABLE tb_name SET TAG tag_name1=new_tag_value1,tag_name2=new_tag_value2...;
|
||||
```
|
||||
|
||||
### Modify Table Lifespan
|
||||
|
|
|
|||
|
|
@ -28,13 +28,14 @@ In this document, it specifically refers to the internal levels of the second-le
|
|||
|
||||
- Default compression algorithms list and applicable range for each data type
|
||||
|
||||
| Data Type | Available Encoding Algorithms | Default Encoding Algorithm | Available Compression Algorithms|Default Compression Algorithm| Default Compression Level|
|
||||
| :-----------:|:----------:|:-------:|:-------:|:----------:|:----:|
|
||||
| tinyint/untinyint/smallint/usmallint/int/uint | simple8b| simple8b | lz4/zlib/zstd/xz| lz4 | medium|
|
||||
| bigint/ubigint/timestamp | simple8b/delta-i | delta-i |lz4/zlib/zstd/xz | lz4| medium|
|
||||
|float/double | delta-d|delta-d |lz4/zlib/zstd/xz/tsz|lz4| medium|
|
||||
|binary/nchar| disabled| disabled|lz4/zlib/zstd/xz| lz4| medium|
|
||||
|bool| bit-packing| bit-packing| lz4/zlib/zstd/xz| lz4| medium|
|
||||
| Data Type |Available Encoding Algorithms | Default Encoding Algorithm | Available Compression Algorithms | Default Compression Algorithm | Default Compression Level |
|
||||
|:------------------------------------:|:----------------:|:-----------:|:--------------------:|:----:|:------:|
|
||||
| int/uint | simple8b | simple8b | lz4/zlib/zstd/xz | lz4 | medium |
|
||||
| tinyint/untinyint/smallint/usmallint | simple8b | simple8b | lz4/zlib/zstd/xz | zlib | medium |
|
||||
| bigint/ubigint/timestamp | simple8b/delta-i | delta-i | lz4/zlib/zstd/xz | lz4 | medium |
|
||||
| float/double | delta-d | delta-d | lz4/zlib/zstd/xz/tsz | lz4 | medium |
|
||||
| binary/nchar | disabled | disabled | lz4/zlib/zstd/xz | zstd | medium |
|
||||
| bool | bit-packing | bit-packing | lz4/zlib/zstd/xz | zstd | medium |
|
||||
|
||||
## SQL Syntax
|
||||
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@ TDengine 提供了丰富的应用程序开发接口，为了便于用户快速
|
|||
|
||||
关键不同点在于：
|
||||
|
||||
1. 使用 原生连接，需要保证客户端的驱动程序 taosc 和服务端的 TDengine 版本配套。
|
||||
1. 使用 原生连接，需要保证客户端的驱动程序 taosc 和服务端的 TDengine 版本保持一致。
|
||||
2. 使用 REST 连接，用户无需安装客户端驱动程序 taosc，具有跨平台易用的优势，但是无法体验数据订阅和二进制数据类型等功能。另外与 原生连接 和 WebSocket 连接相比，REST连接的性能最低。REST 接口是无状态的。在使用 REST 连接时，需要在 SQL 中指定表、超级表的数据库名称。
|
||||
3. 使用 WebSocket 连接，用户也无需安装客户端驱动程序 taosc。
|
||||
4. 连接云服务实例，必须使用 REST 连接 或 WebSocket 连接。
|
||||
|
|
|
|||
Binary file not shown.
|
After Width: | Height: | Size: 212 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 222 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 95 KiB |
|
|
@ -145,6 +145,44 @@ TDinsight 仪表盘旨在提供 TDengine 相关资源的使用情况和状态，
|
|||
|
||||
还有上述分类的细分维度折线图。
|
||||
|
||||
### 预配置告警规则自动导入
|
||||
|
||||
涛思总结用户使用经验，整理出 14 个常用的告警规则（alert rule），能够对集群关键指标进行监测并及时上报指标异常、超限等告警信息。
|
||||
从 TDengine-server 3.3.4.3 版本（tdengine-datasource 3.6.3）开始，TDengine Datasource 支持预配置告警规则自动导入功能，用户可将 14 个告警规则一键导入 Grafana（11 及以上版本），直接使用。
|
||||
预配置告警规则导入方法如下图所示，在 tdengine-datasource setting 界面，打开 “Load Tengine Alert” 开关，点击 “Save & test” 按钮后，插件会自动加载上述告警规则, 规则会放入以数据源名称 + “-alert” 的 grafana 告警目录中。如不需要，关闭 “Load TDengine Alert” 开关，点击 “Clear TDengine Alert” 旁边的按钮则会清除此数据源已导入的所有告警规则。
|
||||
|
||||
|
||||
|
||||
导入后，点击 Grafana 左侧 “Alert rules” ，可查看当前所有告警规则。
|
||||
用户只需配置联络点（Contact points），即可获取告警通知。联络点配置方法见[告警配置](https://docs.taosdata.com/third-party/visual/grafana/#%E5%91%8A%E8%AD%A6%E9%85%8D%E7%BD%AE)。
|
||||
|
||||
|
||||
|
||||
14 个告警规则具体配置如下：
|
||||
|
||||
| 规则名称| 规则阈值| 无监控数据时的行为 | 数据扫描间隔 |持续时间 | 执行SQL |
|
||||
| ------ | --------- | ---------------- | ----------- |------- |----------------------|
|
||||
|dnode 节点的CPU负载|均值 > 80%|触发告警|5分钟|5分钟 |`select now(), dnode_id, last(cpu_system) as cup_use from log.taosd_dnodes_info where _ts >= (now- 5m) and _ts < now partition by dnode_id having first(_ts) > 0 `|
|
||||
|dnode 节点的的内存 |均值 > 60%|触发告警|5分钟|5分钟|`select now(), dnode_id, last(mem_engine) / last(mem_total) * 100 as taosd from log.taosd_dnodes_info where _ts >= (now- 5m) and _ts <now partition by dnode_id`|
|
||||
|dnode 节点的磁盘容量占用 | > 80%|触发告警|5分钟|5分钟|`select now(), dnode_id, data_dir_level, data_dir_name, last(used) / last(total) * 100 as used from log.taosd_dnodes_data_dirs where _ts >= (now - 5m) and _ts < now partition by dnode_id, data_dir_level, data_dir_name`|
|
||||
|集群授权到期 |< 60天|触发告警|1天|0秒|`select now(), cluster_id, last(grants_expire_time) / 86400 as expire_time from log.taosd_cluster_info where _ts >= (now - 24h) and _ts < now partition by cluster_id having first(_ts) > 0 `|
|
||||
|测点数达到授权测点数|>= 90%|触发告警|1天|0秒|`select now(), cluster_id, CASE WHEN max(grants_timeseries_total) > 0.0 THEN max(grants_timeseries_used) /max(grants_timeseries_total) * 100.0 ELSE 0.0 END AS result from log.taosd_cluster_info where _ts >= (now - 30s) and _ts < now partition by cluster_id having timetruncate(first(_ts), 1m) > 0`|
|
||||
|查询并发请求数 | > 100|不触发报警|1分钟|0秒|`select now() as ts, count(*) as slow_count from performance_schema.perf_queries`|
|
||||
|慢查询执行最长时间 （无时间窗口） |> 300秒|不触发报警|1分钟|0秒|`select now() as ts, count(*) as slow_count from performance_schema.perf_queries where exec_usec>300000000`|
|
||||
|dnode下线 |total != alive|触发告警|30秒|0秒|`select now(), cluster_id, last(dnodes_total) - last(dnodes_alive) as dnode_offline from log.taosd_cluster_info where _ts >= (now -30s) and _ts < now partition by cluster_id having first(_ts) > 0`|
|
||||
|vnode下线 |total != alive|触发告警|30秒|0秒|`select now(), cluster_id, last(vnodes_total) - last(vnodes_alive) as vnode_offline from log.taosd_cluster_info where _ts >= (now - 30s) and _ts < now partition by cluster_id having first(_ts) > 0 `|
|
||||
|数据删除请求数 |> 0|不触发报警|30秒|0秒|``select now(), count(`count`) as `delete_count` from log.taos_sql_req where sql_type = 'delete' and _ts >= (now -30s) and _ts < now``|
|
||||
|Adapter RESTful 请求失败 |> 5|不触发报警|30秒|0秒|``select now(), sum(`fail`) as `Failed` from log.adapter_requests where req_type=0 and ts >= (now -30s) and ts < now``|
|
||||
|Adapter WebSocket 请求失败 |> 5|不触发报警|30秒|0秒|``select now(), sum(`fail`) as `Failed` from log.adapter_requests where req_type=1 and ts >= (now -30s) and ts < now``|
|
||||
|dnode 数据上报缺少 |< 3|触发告警|180秒|0秒|`select now(), cluster_id, count(*) as dnode_report from log.taosd_cluster_info where _ts >= (now -180s) and _ts < now partition by cluster_id having timetruncate(first(_ts), 1h) > 0`|
|
||||
|dnode 重启 |max(update_time) > last(update_time)|触发告警|90秒|0秒|`select now(), dnode_id, max(uptime) - last(uptime) as dnode_restart from log.taosd_dnodes_info where _ts >= (now - 90s) and _ts < now partition by dnode_id`|
|
||||
|
||||
用户可参考上述告警规则，根据自己业务需求进行修改与完善。
|
||||
Grafana7.5 及以下版本，Dashboards 与 Alert rules 功能合在一起，而之后的新版本两个功能是分开的。为兼容 Grafana7.5 及以下版本，TDinsight 面板中增加了 Alert Used Only 面板，仅 Grafana7.5 及以下版本需要使用。
|
||||
|
||||
|
||||
|
||||
|
||||
## 升级
|
||||
下面三种方式都可以进行升级：
|
||||
- 用图形界面，若有新版本，可以在 ”TDengine Datasource“ 插件页面点击 update 升级。
|
||||
|
|
@ -155,10 +193,11 @@ TDinsight 仪表盘旨在提供 TDengine 相关资源的使用情况和状态，
|
|||
针对不同的安装方式，卸载时：
|
||||
- 用图形界面，在 ”TDengine Datasource“ 插件页面点击 ”Uninstall“ 卸载。
|
||||
- 通过 `TDinsight.sh` 脚本安装的 TDinsight，可以使用命令行 `TDinsight.sh -R` 清理相关资源。
|
||||
- 手动安装的 TDinsight，要完全卸载，需要清理以下内容：
|
||||
- 手动安装的 TDinsight，要完全卸载，需要按照顺序清理以下内容：
|
||||
1. Grafana 中的 TDinsight Dashboard。
|
||||
2. Grafana 中的 Data Source 数据源。
|
||||
3. 从插件安装目录删除 `tdengine-datasource` 插件。
|
||||
2. Grafana 中的 Alert rules 告警规则。
|
||||
3. Grafana 中的 Data Source 数据源。
|
||||
4. 从插件安装目录删除 `tdengine-datasource` 插件。
|
||||
|
||||
## 附录
|
||||
|
||||
|
|
|
|||
|
|
@ -195,7 +195,7 @@ alter_table_option: {
|
|||
### 修改子表标签值
|
||||
|
||||
```
|
||||
ALTER TABLE tb_name SET TAG tag_name=new_tag_value;
|
||||
ALTER TABLE tb_name SET TAG tag_name1=new_tag_value1,tag_name2=new_tag_value2...;
|
||||
```
|
||||
|
||||
### 修改表生命周期
|
||||
|
|
|
|||
|
|
@ -29,14 +29,15 @@ description: 可配置压缩算法
|
|||
|
||||
- 各个数据类型的默认压缩算法列表和适用范围
|
||||
|
||||
| 数据类型 | 可选编码算法 | 编码算法默认值 | 可选压缩算法|压缩算法默认值| 压缩等级默认值|
|
||||
| :-----------:|:----------:|:-------:|:-------:|:----------:|:----:|
|
||||
| int/uint | simple8b| simple8b | lz4/zlib/zstd/xz| lz4 | medium|
|
||||
| tinyint/untinyint/smallint/usmallint | simple8b| simple8b | lz4/zlib/zstd/xz| zlib | medium|
|
||||
| bigint/ubigint/timestamp | simple8b/delta-i | delta-i |lz4/zlib/zstd/xz | lz4| medium|
|
||||
|float/double | delta-d|delta-d |lz4/zlib/zstd/xz/tsz|lz4| medium|
|
||||
|binary/nchar| disabled| disabled|lz4/zlib/zstd/xz| zstd| medium|
|
||||
|bool| bit-packing| bit-packing| lz4/zlib/zstd/xz| zstd| medium|
|
||||
| 数据类型 | 可选编码算法 | 编码算法默认值 | 可选压缩算法 | 压缩算法默认值 |压缩等级默认值|
|
||||
|:------------------------------------:|:----------------:|:-----------:|:--------------------:|:----:|:------:|
|
||||
| int/uint | simple8b | simple8b | lz4/zlib/zstd/xz | lz4 | medium |
|
||||
| tinyint/untinyint/smallint/usmallint | simple8b | simple8b | lz4/zlib/zstd/xz | zlib | medium |
|
||||
| bigint/ubigint/timestamp | simple8b/delta-i | delta-i | lz4/zlib/zstd/xz | lz4 | medium |
|
||||
| float/double | delta-d | delta-d | lz4/zlib/zstd/xz/tsz | lz4 | medium |
|
||||
| binary/nchar | disabled | disabled | lz4/zlib/zstd/xz | zstd | medium |
|
||||
| bool | bit-packing | bit-packing | lz4/zlib/zstd/xz | zstd | medium |
|
||||
|
||||
|
||||
## SQL 语法
|
||||
|
||||
|
|
|
|||
|
|
@ -48,13 +48,13 @@ void atomic_store_8(int8_t volatile *ptr, int8_t val);
|
|||
void atomic_store_16(int16_t volatile *ptr, int16_t val);
|
||||
void atomic_store_32(int32_t volatile *ptr, int32_t val);
|
||||
void atomic_store_64(int64_t volatile *ptr, int64_t val);
|
||||
double atomic_store_double(double volatile *ptr, double val);
|
||||
void atomic_store_double(double volatile *ptr, double val);
|
||||
void atomic_store_ptr(void *ptr, void *val);
|
||||
int8_t atomic_exchange_8(int8_t volatile *ptr, int8_t val);
|
||||
int16_t atomic_exchange_16(int16_t volatile *ptr, int16_t val);
|
||||
int32_t atomic_exchange_32(int32_t volatile *ptr, int32_t val);
|
||||
int64_t atomic_exchange_64(int64_t volatile *ptr, int64_t val);
|
||||
double atomic_exchange_double(double volatile *ptr, int64_t val);
|
||||
double atomic_exchange_double(double volatile *ptr, double val);
|
||||
void *atomic_exchange_ptr(void *ptr, void *val);
|
||||
int8_t atomic_val_compare_exchange_8(int8_t volatile *ptr, int8_t oldval, int8_t newval);
|
||||
int16_t atomic_val_compare_exchange_16(int16_t volatile *ptr, int16_t oldval, int16_t newval);
|
||||
|
|
@ -71,7 +71,7 @@ int16_t atomic_fetch_add_16(int16_t volatile *ptr, int16_t val);
|
|||
int32_t atomic_fetch_add_32(int32_t volatile *ptr, int32_t val);
|
||||
int64_t atomic_fetch_add_64(int64_t volatile *ptr, int64_t val);
|
||||
double atomic_fetch_add_double(double volatile *ptr, double val);
|
||||
void *atomic_fetch_add_ptr(void *ptr, void *val);
|
||||
void *atomic_fetch_add_ptr(void *ptr, int64_t val);
|
||||
int8_t atomic_sub_fetch_8(int8_t volatile *ptr, int8_t val);
|
||||
int16_t atomic_sub_fetch_16(int16_t volatile *ptr, int16_t val);
|
||||
int32_t atomic_sub_fetch_32(int32_t volatile *ptr, int32_t val);
|
||||
|
|
@ -82,37 +82,37 @@ int16_t atomic_fetch_sub_16(int16_t volatile *ptr, int16_t val);
|
|||
int32_t atomic_fetch_sub_32(int32_t volatile *ptr, int32_t val);
|
||||
int64_t atomic_fetch_sub_64(int64_t volatile *ptr, int64_t val);
|
||||
double atomic_fetch_sub_double(double volatile *ptr, double val);
|
||||
void *atomic_fetch_sub_ptr(void *ptr, void *val);
|
||||
void *atomic_fetch_sub_ptr(void *ptr, int64_t val);
|
||||
int8_t atomic_and_fetch_8(int8_t volatile *ptr, int8_t val);
|
||||
int16_t atomic_and_fetch_16(int16_t volatile *ptr, int16_t val);
|
||||
int32_t atomic_and_fetch_32(int32_t volatile *ptr, int32_t val);
|
||||
int64_t atomic_and_fetch_64(int64_t volatile *ptr, int64_t val);
|
||||
void *atomic_and_fetch_ptr(void *ptr, void *val);
|
||||
void *atomic_and_fetch_ptr(void *ptr, int64_t val);
|
||||
int8_t atomic_fetch_and_8(int8_t volatile *ptr, int8_t val);
|
||||
int16_t atomic_fetch_and_16(int16_t volatile *ptr, int16_t val);
|
||||
int32_t atomic_fetch_and_32(int32_t volatile *ptr, int32_t val);
|
||||
int64_t atomic_fetch_and_64(int64_t volatile *ptr, int64_t val);
|
||||
void *atomic_fetch_and_ptr(void *ptr, void *val);
|
||||
void *atomic_fetch_and_ptr(void *ptr, int64_t val);
|
||||
int8_t atomic_or_fetch_8(int8_t volatile *ptr, int8_t val);
|
||||
int16_t atomic_or_fetch_16(int16_t volatile *ptr, int16_t val);
|
||||
int32_t atomic_or_fetch_32(int32_t volatile *ptr, int32_t val);
|
||||
int64_t atomic_or_fetch_64(int64_t volatile *ptr, int64_t val);
|
||||
void *atomic_or_fetch_ptr(void *ptr, void *val);
|
||||
void *atomic_or_fetch_ptr(void *ptr, int64_t val);
|
||||
int8_t atomic_fetch_or_8(int8_t volatile *ptr, int8_t val);
|
||||
int16_t atomic_fetch_or_16(int16_t volatile *ptr, int16_t val);
|
||||
int32_t atomic_fetch_or_32(int32_t volatile *ptr, int32_t val);
|
||||
int64_t atomic_fetch_or_64(int64_t volatile *ptr, int64_t val);
|
||||
void *atomic_fetch_or_ptr(void *ptr, void *val);
|
||||
void *atomic_fetch_or_ptr(void *ptr, int64_t val);
|
||||
int8_t atomic_xor_fetch_8(int8_t volatile *ptr, int8_t val);
|
||||
int16_t atomic_xor_fetch_16(int16_t volatile *ptr, int16_t val);
|
||||
int32_t atomic_xor_fetch_32(int32_t volatile *ptr, int32_t val);
|
||||
int64_t atomic_xor_fetch_64(int64_t volatile *ptr, int64_t val);
|
||||
void *atomic_xor_fetch_ptr(void *ptr, void *val);
|
||||
void *atomic_xor_fetch_ptr(void *ptr, int64_t val);
|
||||
int8_t atomic_fetch_xor_8(int8_t volatile *ptr, int8_t val);
|
||||
int16_t atomic_fetch_xor_16(int16_t volatile *ptr, int16_t val);
|
||||
int32_t atomic_fetch_xor_32(int32_t volatile *ptr, int32_t val);
|
||||
int64_t atomic_fetch_xor_64(int64_t volatile *ptr, int64_t val);
|
||||
void *atomic_fetch_xor_ptr(void *ptr, void *val);
|
||||
void *atomic_fetch_xor_ptr(void *ptr, int64_t val);
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#define tmemory_barrier(order) MemoryBarrier()
|
||||
|
|
|
|||
|
|
@ -1,59 +1,80 @@
|
|||
import subprocess
|
||||
import re
|
||||
|
||||
# 执行 git fetch 命令并捕获输出
|
||||
def git_fetch():
|
||||
result = subprocess.run(['git', 'fetch'], capture_output=True, text=True)
|
||||
return result
|
||||
|
||||
# 解析分支名称
|
||||
def git_prune():
|
||||
# git remote prune origin
|
||||
print("git remote prune origin")
|
||||
result = subprocess.run(['git', 'remote', 'prune', 'origin'], capture_output=True, text=True)
|
||||
return result
|
||||
|
||||
def parse_branch_name_type1(error_output):
|
||||
# 使用正则表达式匹配 'is at' 前的分支名称
|
||||
# error: cannot lock ref 'refs/remotes/origin/fix/3.0/TD-32817': is at 7af5 but expected eaba
|
||||
# match the branch name before ‘is at’ with a regular expression
|
||||
match = re.search(r"error: cannot lock ref '(refs/remotes/origin/[^']+)': is at", error_output)
|
||||
if match:
|
||||
return match.group(1)
|
||||
return None
|
||||
|
||||
# 解析第二种错误中的分支名称
|
||||
def parse_branch_name_type2(error_output):
|
||||
# 使用正则表达式匹配 'exists' 前的第一个引号内的分支名称
|
||||
# match the branch name before ‘exists; cannot create’ with a regular expression
|
||||
match = re.search(r"'(refs/remotes/origin/[^']+)' exists;", error_output)
|
||||
if match:
|
||||
return match.group(1)
|
||||
return None
|
||||
|
||||
# 执行 git update-ref -d 命令
|
||||
# parse branch name from error output of git remote prune origin
|
||||
def parse_branch_name_type3(error_output):
|
||||
# match the branch name before the first single quote before 'Unable to' with a regular expression
|
||||
# git error: could not delete references: cannot lock ref 'refs/remotes/origin/test/3.0/TS-4893': Unable to create 'D:/workspace/main/TDinternal/community/.git/refs/remotes/origin/test/3.0/TS-4893.lock': File exists
|
||||
match = re.search(r"references: cannot lock ref '(refs/remotes/origin/[^']+)': Unable to", error_output)
|
||||
if match:
|
||||
return match.group(1)
|
||||
return None
|
||||
|
||||
|
||||
# execute git update-ref -d <branch_name> to delete the ref
|
||||
def git_update_ref(branch_name):
|
||||
if branch_name:
|
||||
subprocess.run(['git', 'update-ref', '-d', f'{branch_name}'], check=True)
|
||||
|
||||
# 解析错误类型并执行相应的修复操作
|
||||
# parse error type and execute corresponding repair operation
|
||||
def handle_error(error_output):
|
||||
# 错误类型1：本地引用的提交ID与远程不一致
|
||||
if "is at" in error_output and "but expected" in error_output:
|
||||
branch_name = parse_branch_name_type1(error_output)
|
||||
if branch_name:
|
||||
print(f"Detected error type 1, attempting to delete ref for branch: {branch_name}")
|
||||
git_update_ref(branch_name)
|
||||
else:
|
||||
print("Error parsing branch name for type 1.")
|
||||
# 错误类型2：尝试创建新的远程引用时，本地已经存在同名的引用
|
||||
elif "exists; cannot create" in error_output:
|
||||
branch_name = parse_branch_name_type2(error_output)
|
||||
if branch_name:
|
||||
print(f"Detected error type 2, attempting to delete ref for branch: {branch_name}")
|
||||
git_update_ref(branch_name)
|
||||
else:
|
||||
print("Error parsing branch name for type 2.")
|
||||
error_types = [
|
||||
("is at", "but expected", parse_branch_name_type1, "type 1"),
|
||||
("exists; cannot create", None, parse_branch_name_type2, "type 2"),
|
||||
("Unable to create", "File exists", parse_branch_name_type3, "type 3")
|
||||
]
|
||||
|
||||
for error_type in error_types:
|
||||
if error_type[0] in error_output and (error_type[1] is None or error_type[1] in error_output):
|
||||
branch_name = error_type[2](error_output)
|
||||
if branch_name:
|
||||
print(f"Detected error {error_type[3]}, attempting to delete ref for branch: {branch_name}")
|
||||
git_update_ref(branch_name)
|
||||
else:
|
||||
print(f"Error parsing branch name for {error_type[3]}.")
|
||||
break
|
||||
|
||||
# 主函数
|
||||
def main():
|
||||
fetch_result = git_fetch()
|
||||
if fetch_result.returncode != 0: # 如果 git fetch 命令失败
|
||||
if fetch_result.returncode != 0:
|
||||
error_output = fetch_result.stderr
|
||||
handle_error(error_output)
|
||||
else:
|
||||
print("Git fetch successful.")
|
||||
|
||||
prune_result = git_prune()
|
||||
print(prune_result.returncode)
|
||||
if prune_result.returncode != 0:
|
||||
error_output = prune_result.stderr
|
||||
print(error_output)
|
||||
handle_error(error_output)
|
||||
else:
|
||||
print("Git prune successful.")
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
|
@ -52,6 +52,22 @@
|
|||
|
||||
#define TMQ_META_VERSION "1.0"
|
||||
|
||||
static bool tmqAddJsonObjectItem(cJSON *object, const char *string, cJSON *item){
|
||||
bool ret = cJSON_AddItemToObject(object, string, item);
|
||||
if (!ret){
|
||||
cJSON_Delete(item);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
static bool tmqAddJsonArrayItem(cJSON *array, cJSON *item){
|
||||
bool ret = cJSON_AddItemToArray(array, item);
|
||||
if (!ret){
|
||||
cJSON_Delete(item);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
static int32_t tmqWriteBatchMetaDataImpl(TAOS* taos, void* meta, int32_t metaLen);
|
||||
static tb_uid_t processSuid(tb_uid_t suid, char* db) { return suid + MurmurHash3_32(db, strlen(db)); }
|
||||
static void buildCreateTableJson(SSchemaWrapper* schemaRow, SSchemaWrapper* schemaTag, char* name, int64_t id, int8_t t,
|
||||
|
|
@ -68,41 +84,43 @@ static void buildCreateTableJson(SSchemaWrapper* schemaRow, SSchemaWrapper* sche
|
|||
cJSON* type = cJSON_CreateString("create");
|
||||
RAW_NULL_CHECK(type);
|
||||
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "type", type));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "type", type));
|
||||
cJSON* tableType = cJSON_CreateString(t == TSDB_NORMAL_TABLE ? "normal" : "super");
|
||||
RAW_NULL_CHECK(tableType);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "tableType", tableType));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "tableType", tableType));
|
||||
cJSON* tableName = cJSON_CreateString(name);
|
||||
RAW_NULL_CHECK(tableName);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "tableName", tableName));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "tableName", tableName));
|
||||
|
||||
cJSON* columns = cJSON_CreateArray();
|
||||
RAW_NULL_CHECK(columns);
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "columns", columns));
|
||||
|
||||
for (int i = 0; i < schemaRow->nCols; i++) {
|
||||
cJSON* column = cJSON_CreateObject();
|
||||
RAW_NULL_CHECK(column);
|
||||
RAW_FALSE_CHECK(tmqAddJsonArrayItem(columns, column));
|
||||
SSchema* s = schemaRow->pSchema + i;
|
||||
cJSON* cname = cJSON_CreateString(s->name);
|
||||
RAW_NULL_CHECK(cname);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(column, "name", cname));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(column, "name", cname));
|
||||
cJSON* ctype = cJSON_CreateNumber(s->type);
|
||||
RAW_NULL_CHECK(ctype);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(column, "type", ctype));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(column, "type", ctype));
|
||||
if (s->type == TSDB_DATA_TYPE_BINARY || s->type == TSDB_DATA_TYPE_VARBINARY || s->type == TSDB_DATA_TYPE_GEOMETRY) {
|
||||
int32_t length = s->bytes - VARSTR_HEADER_SIZE;
|
||||
cJSON* cbytes = cJSON_CreateNumber(length);
|
||||
RAW_NULL_CHECK(cbytes);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(column, "length", cbytes));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(column, "length", cbytes));
|
||||
} else if (s->type == TSDB_DATA_TYPE_NCHAR) {
|
||||
int32_t length = (s->bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE;
|
||||
cJSON* cbytes = cJSON_CreateNumber(length);
|
||||
RAW_NULL_CHECK(cbytes);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(column, "length", cbytes));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(column, "length", cbytes));
|
||||
}
|
||||
cJSON* isPk = cJSON_CreateBool(s->flags & COL_IS_KEY);
|
||||
RAW_NULL_CHECK(isPk);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(column, "isPrimarykey", isPk));
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToArray(columns, column));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(column, "isPrimarykey", isPk));
|
||||
|
||||
if (pColCmprRow == NULL) {
|
||||
continue;
|
||||
|
|
@ -124,44 +142,44 @@ static void buildCreateTableJson(SSchemaWrapper* schemaRow, SSchemaWrapper* sche
|
|||
|
||||
cJSON* encodeJson = cJSON_CreateString(encode);
|
||||
RAW_NULL_CHECK(encodeJson);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(column, "encode", encodeJson));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(column, "encode", encodeJson));
|
||||
|
||||
cJSON* compressJson = cJSON_CreateString(compress);
|
||||
RAW_NULL_CHECK(compressJson);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(column, "compress", compressJson));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(column, "compress", compressJson));
|
||||
|
||||
cJSON* levelJson = cJSON_CreateString(level);
|
||||
RAW_NULL_CHECK(levelJson);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(column, "level", levelJson));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(column, "level", levelJson));
|
||||
}
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "columns", columns));
|
||||
|
||||
cJSON* tags = cJSON_CreateArray();
|
||||
RAW_NULL_CHECK(tags);
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "tags", tags));
|
||||
|
||||
for (int i = 0; schemaTag && i < schemaTag->nCols; i++) {
|
||||
cJSON* tag = cJSON_CreateObject();
|
||||
RAW_NULL_CHECK(tag);
|
||||
RAW_FALSE_CHECK(tmqAddJsonArrayItem(tags, tag));
|
||||
SSchema* s = schemaTag->pSchema + i;
|
||||
cJSON* tname = cJSON_CreateString(s->name);
|
||||
RAW_NULL_CHECK(tname);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(tag, "name", tname));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(tag, "name", tname));
|
||||
cJSON* ttype = cJSON_CreateNumber(s->type);
|
||||
RAW_NULL_CHECK(ttype);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(tag, "type", ttype));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(tag, "type", ttype));
|
||||
if (s->type == TSDB_DATA_TYPE_BINARY || s->type == TSDB_DATA_TYPE_VARBINARY || s->type == TSDB_DATA_TYPE_GEOMETRY) {
|
||||
int32_t length = s->bytes - VARSTR_HEADER_SIZE;
|
||||
cJSON* cbytes = cJSON_CreateNumber(length);
|
||||
RAW_NULL_CHECK(cbytes);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(tag, "length", cbytes));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(tag, "length", cbytes));
|
||||
} else if (s->type == TSDB_DATA_TYPE_NCHAR) {
|
||||
int32_t length = (s->bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE;
|
||||
cJSON* cbytes = cJSON_CreateNumber(length);
|
||||
RAW_NULL_CHECK(cbytes);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(tag, "length", cbytes));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(tag, "length", cbytes));
|
||||
}
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToArray(tags, tag));
|
||||
}
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "tags", tags));
|
||||
|
||||
end:
|
||||
*pJson = json;
|
||||
|
|
@ -175,7 +193,7 @@ static int32_t setCompressOption(cJSON* json, uint32_t para) {
|
|||
RAW_NULL_CHECK(encodeStr);
|
||||
cJSON* encodeJson = cJSON_CreateString(encodeStr);
|
||||
RAW_NULL_CHECK(encodeJson);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "encode", encodeJson));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "encode", encodeJson));
|
||||
return code;
|
||||
}
|
||||
uint8_t compress = COMPRESS_L2_TYPE_U32(para);
|
||||
|
|
@ -184,7 +202,7 @@ static int32_t setCompressOption(cJSON* json, uint32_t para) {
|
|||
RAW_NULL_CHECK(compressStr);
|
||||
cJSON* compressJson = cJSON_CreateString(compressStr);
|
||||
RAW_NULL_CHECK(compressJson);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "compress", compressJson));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "compress", compressJson));
|
||||
return code;
|
||||
}
|
||||
uint8_t level = COMPRESS_L2_TYPE_LEVEL_U32(para);
|
||||
|
|
@ -193,7 +211,7 @@ static int32_t setCompressOption(cJSON* json, uint32_t para) {
|
|||
RAW_NULL_CHECK(levelStr);
|
||||
cJSON* levelJson = cJSON_CreateString(levelStr);
|
||||
RAW_NULL_CHECK(levelJson);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "level", levelJson));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "level", levelJson));
|
||||
return code;
|
||||
}
|
||||
|
||||
|
|
@ -214,19 +232,19 @@ static void buildAlterSTableJson(void* alterData, int32_t alterDataLen, cJSON**
|
|||
RAW_NULL_CHECK(json);
|
||||
cJSON* type = cJSON_CreateString("alter");
|
||||
RAW_NULL_CHECK(type);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "type", type));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "type", type));
|
||||
SName name = {0};
|
||||
RAW_RETURN_CHECK(tNameFromString(&name, req.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE));
|
||||
cJSON* tableType = cJSON_CreateString("super");
|
||||
RAW_NULL_CHECK(tableType);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "tableType", tableType));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "tableType", tableType));
|
||||
cJSON* tableName = cJSON_CreateString(name.tname);
|
||||
RAW_NULL_CHECK(tableName);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "tableName", tableName));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "tableName", tableName));
|
||||
|
||||
cJSON* alterType = cJSON_CreateNumber(req.alterType);
|
||||
RAW_NULL_CHECK(alterType);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "alterType", alterType));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "alterType", alterType));
|
||||
switch (req.alterType) {
|
||||
case TSDB_ALTER_TABLE_ADD_TAG:
|
||||
case TSDB_ALTER_TABLE_ADD_COLUMN: {
|
||||
|
|
@ -234,22 +252,22 @@ static void buildAlterSTableJson(void* alterData, int32_t alterDataLen, cJSON**
|
|||
RAW_NULL_CHECK(field);
|
||||
cJSON* colName = cJSON_CreateString(field->name);
|
||||
RAW_NULL_CHECK(colName);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colName", colName));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colName", colName));
|
||||
cJSON* colType = cJSON_CreateNumber(field->type);
|
||||
RAW_NULL_CHECK(colType);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colType", colType));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colType", colType));
|
||||
|
||||
if (field->type == TSDB_DATA_TYPE_BINARY || field->type == TSDB_DATA_TYPE_VARBINARY ||
|
||||
field->type == TSDB_DATA_TYPE_GEOMETRY) {
|
||||
int32_t length = field->bytes - VARSTR_HEADER_SIZE;
|
||||
cJSON* cbytes = cJSON_CreateNumber(length);
|
||||
RAW_NULL_CHECK(cbytes);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colLength", cbytes));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colLength", cbytes));
|
||||
} else if (field->type == TSDB_DATA_TYPE_NCHAR) {
|
||||
int32_t length = (field->bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE;
|
||||
cJSON* cbytes = cJSON_CreateNumber(length);
|
||||
RAW_NULL_CHECK(cbytes);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colLength", cbytes));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colLength", cbytes));
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
|
@ -258,22 +276,22 @@ static void buildAlterSTableJson(void* alterData, int32_t alterDataLen, cJSON**
|
|||
RAW_NULL_CHECK(field);
|
||||
cJSON* colName = cJSON_CreateString(field->name);
|
||||
RAW_NULL_CHECK(colName);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colName", colName));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colName", colName));
|
||||
cJSON* colType = cJSON_CreateNumber(field->type);
|
||||
RAW_NULL_CHECK(colType);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colType", colType));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colType", colType));
|
||||
|
||||
if (field->type == TSDB_DATA_TYPE_BINARY || field->type == TSDB_DATA_TYPE_VARBINARY ||
|
||||
field->type == TSDB_DATA_TYPE_GEOMETRY) {
|
||||
int32_t length = field->bytes - VARSTR_HEADER_SIZE;
|
||||
cJSON* cbytes = cJSON_CreateNumber(length);
|
||||
RAW_NULL_CHECK(cbytes);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colLength", cbytes));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colLength", cbytes));
|
||||
} else if (field->type == TSDB_DATA_TYPE_NCHAR) {
|
||||
int32_t length = (field->bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE;
|
||||
cJSON* cbytes = cJSON_CreateNumber(length);
|
||||
RAW_NULL_CHECK(cbytes);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colLength", cbytes));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colLength", cbytes));
|
||||
}
|
||||
RAW_RETURN_CHECK(setCompressOption(json, field->compress));
|
||||
break;
|
||||
|
|
@ -284,7 +302,7 @@ static void buildAlterSTableJson(void* alterData, int32_t alterDataLen, cJSON**
|
|||
RAW_NULL_CHECK(field);
|
||||
cJSON* colName = cJSON_CreateString(field->name);
|
||||
RAW_NULL_CHECK(colName);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colName", colName));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colName", colName));
|
||||
break;
|
||||
}
|
||||
case TSDB_ALTER_TABLE_UPDATE_TAG_BYTES:
|
||||
|
|
@ -293,21 +311,21 @@ static void buildAlterSTableJson(void* alterData, int32_t alterDataLen, cJSON**
|
|||
RAW_NULL_CHECK(field);
|
||||
cJSON* colName = cJSON_CreateString(field->name);
|
||||
RAW_NULL_CHECK(colName);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colName", colName));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colName", colName));
|
||||
cJSON* colType = cJSON_CreateNumber(field->type);
|
||||
RAW_NULL_CHECK(colType);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colType", colType));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colType", colType));
|
||||
if (field->type == TSDB_DATA_TYPE_BINARY || field->type == TSDB_DATA_TYPE_VARBINARY ||
|
||||
field->type == TSDB_DATA_TYPE_GEOMETRY) {
|
||||
int32_t length = field->bytes - VARSTR_HEADER_SIZE;
|
||||
cJSON* cbytes = cJSON_CreateNumber(length);
|
||||
RAW_NULL_CHECK(cbytes);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colLength", cbytes));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colLength", cbytes));
|
||||
} else if (field->type == TSDB_DATA_TYPE_NCHAR) {
|
||||
int32_t length = (field->bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE;
|
||||
cJSON* cbytes = cJSON_CreateNumber(length);
|
||||
RAW_NULL_CHECK(cbytes);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colLength", cbytes));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colLength", cbytes));
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
|
@ -319,10 +337,10 @@ static void buildAlterSTableJson(void* alterData, int32_t alterDataLen, cJSON**
|
|||
RAW_NULL_CHECK(newField);
|
||||
cJSON* colName = cJSON_CreateString(oldField->name);
|
||||
RAW_NULL_CHECK(colName);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colName", colName));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colName", colName));
|
||||
cJSON* colNewName = cJSON_CreateString(newField->name);
|
||||
RAW_NULL_CHECK(colNewName);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colNewName", colNewName));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colNewName", colNewName));
|
||||
break;
|
||||
}
|
||||
case TSDB_ALTER_TABLE_UPDATE_COLUMN_COMPRESS: {
|
||||
|
|
@ -330,7 +348,7 @@ static void buildAlterSTableJson(void* alterData, int32_t alterDataLen, cJSON**
|
|||
RAW_NULL_CHECK(field);
|
||||
cJSON* colName = cJSON_CreateString(field->name);
|
||||
RAW_NULL_CHECK(colName);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colName", colName));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colName", colName));
|
||||
RAW_RETURN_CHECK(setCompressOption(json, field->bytes));
|
||||
break;
|
||||
}
|
||||
|
|
@ -391,51 +409,47 @@ static void buildChildElement(cJSON* json, SVCreateTbReq* pCreateReq) {
|
|||
int64_t id = pCreateReq->uid;
|
||||
uint8_t tagNum = pCreateReq->ctb.tagNum;
|
||||
int32_t code = 0;
|
||||
cJSON* tags = NULL;
|
||||
SArray* pTagVals = NULL;
|
||||
char* pJson = NULL;
|
||||
|
||||
cJSON* tableName = cJSON_CreateString(name);
|
||||
RAW_NULL_CHECK(tableName);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "tableName", tableName));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "tableName", tableName));
|
||||
cJSON* using = cJSON_CreateString(sname);
|
||||
RAW_NULL_CHECK(using);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "using", using));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "using", using));
|
||||
cJSON* tagNumJson = cJSON_CreateNumber(tagNum);
|
||||
RAW_NULL_CHECK(tagNumJson);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "tagNum", tagNumJson));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "tagNum", tagNumJson));
|
||||
|
||||
tags = cJSON_CreateArray();
|
||||
cJSON* tags = cJSON_CreateArray();
|
||||
RAW_NULL_CHECK(tags);
|
||||
SArray* pTagVals = NULL;
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "tags", tags));
|
||||
RAW_RETURN_CHECK(tTagToValArray(pTag, &pTagVals));
|
||||
|
||||
if (tTagIsJson(pTag)) {
|
||||
STag* p = (STag*)pTag;
|
||||
if (p->nTag == 0) {
|
||||
uError("p->nTag == 0");
|
||||
goto end;
|
||||
}
|
||||
char* pJson = NULL;
|
||||
parseTagDatatoJson(pTag, &pJson, NULL);
|
||||
if (pJson == NULL) {
|
||||
uError("parseTagDatatoJson failed, pJson == NULL");
|
||||
goto end;
|
||||
}
|
||||
RAW_NULL_CHECK(pJson);
|
||||
cJSON* tag = cJSON_CreateObject();
|
||||
RAW_NULL_CHECK(tag);
|
||||
RAW_FALSE_CHECK(tmqAddJsonArrayItem(tags, tag));
|
||||
STagVal* pTagVal = taosArrayGet(pTagVals, 0);
|
||||
RAW_NULL_CHECK(pTagVal);
|
||||
char* ptname = taosArrayGet(tagName, 0);
|
||||
RAW_NULL_CHECK(ptname);
|
||||
cJSON* tname = cJSON_CreateString(ptname);
|
||||
RAW_NULL_CHECK(tname);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(tag, "name", tname));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(tag, "name", tname));
|
||||
cJSON* ttype = cJSON_CreateNumber(TSDB_DATA_TYPE_JSON);
|
||||
RAW_NULL_CHECK(ttype);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(tag, "type", ttype));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(tag, "type", ttype));
|
||||
cJSON* tvalue = cJSON_CreateString(pJson);
|
||||
RAW_NULL_CHECK(tvalue);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(tag, "value", tvalue));
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToArray(tags, tag));
|
||||
taosMemoryFree(pJson);
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(tag, "value", tvalue));
|
||||
goto end;
|
||||
}
|
||||
|
||||
|
|
@ -444,36 +458,34 @@ static void buildChildElement(cJSON* json, SVCreateTbReq* pCreateReq) {
|
|||
RAW_NULL_CHECK(pTagVal);
|
||||
cJSON* tag = cJSON_CreateObject();
|
||||
RAW_NULL_CHECK(tag);
|
||||
RAW_FALSE_CHECK(tmqAddJsonArrayItem(tags, tag));
|
||||
char* ptname = taosArrayGet(tagName, i);
|
||||
RAW_NULL_CHECK(ptname);
|
||||
cJSON* tname = cJSON_CreateString(ptname);
|
||||
RAW_NULL_CHECK(tname);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(tag, "name", tname));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(tag, "name", tname));
|
||||
cJSON* ttype = cJSON_CreateNumber(pTagVal->type);
|
||||
RAW_NULL_CHECK(ttype);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(tag, "type", ttype));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(tag, "type", ttype));
|
||||
|
||||
cJSON* tvalue = NULL;
|
||||
if (IS_VAR_DATA_TYPE(pTagVal->type)) {
|
||||
char* buf = NULL;
|
||||
int64_t bufSize = 0;
|
||||
if (pTagVal->type == TSDB_DATA_TYPE_VARBINARY) {
|
||||
bufSize = pTagVal->nData * 2 + 2 + 3;
|
||||
} else {
|
||||
bufSize = pTagVal->nData + 3;
|
||||
}
|
||||
buf = taosMemoryCalloc(bufSize, 1);
|
||||
|
||||
char* buf = taosMemoryCalloc(bufSize, 1);
|
||||
RAW_NULL_CHECK(buf);
|
||||
if (!buf) goto end;
|
||||
if (dataConverToStr(buf, bufSize, pTagVal->type, pTagVal->pData, pTagVal->nData, NULL) != TSDB_CODE_SUCCESS) {
|
||||
taosMemoryFree(buf);
|
||||
goto end;
|
||||
}
|
||||
|
||||
tvalue = cJSON_CreateString(buf);
|
||||
RAW_NULL_CHECK(tvalue);
|
||||
taosMemoryFree(buf);
|
||||
RAW_NULL_CHECK(tvalue);
|
||||
} else {
|
||||
double val = 0;
|
||||
GET_TYPED_DATA(val, double, pTagVal->type, &pTagVal->i64);
|
||||
|
|
@ -481,12 +493,11 @@ static void buildChildElement(cJSON* json, SVCreateTbReq* pCreateReq) {
|
|||
RAW_NULL_CHECK(tvalue);
|
||||
}
|
||||
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(tag, "value", tvalue));
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToArray(tags, tag));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(tag, "value", tvalue));
|
||||
}
|
||||
|
||||
end:
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "tags", tags));
|
||||
taosMemoryFree(pJson);
|
||||
taosArrayDestroy(pTagVals);
|
||||
}
|
||||
|
||||
|
|
@ -497,22 +508,23 @@ static void buildCreateCTableJson(SVCreateTbReq* pCreateReq, int32_t nReqs, cJSO
|
|||
RAW_NULL_CHECK(json);
|
||||
cJSON* type = cJSON_CreateString("create");
|
||||
RAW_NULL_CHECK(type);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "type", type));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "type", type));
|
||||
|
||||
cJSON* tableType = cJSON_CreateString("child");
|
||||
RAW_NULL_CHECK(tableType);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "tableType", tableType));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "tableType", tableType));
|
||||
|
||||
buildChildElement(json, pCreateReq);
|
||||
cJSON* createList = cJSON_CreateArray();
|
||||
RAW_NULL_CHECK(createList);
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "createList", createList));
|
||||
|
||||
for (int i = 0; nReqs > 1 && i < nReqs; i++) {
|
||||
cJSON* create = cJSON_CreateObject();
|
||||
RAW_NULL_CHECK(create);
|
||||
buildChildElement(create, pCreateReq + i);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToArray(createList, create));
|
||||
RAW_FALSE_CHECK(tmqAddJsonArrayItem(createList, create));
|
||||
}
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "createList", createList));
|
||||
|
||||
end:
|
||||
*pJson = json;
|
||||
|
|
@ -619,62 +631,62 @@ static void processAlterTable(SMqMetaRsp* metaRsp, cJSON** pJson) {
|
|||
RAW_NULL_CHECK(json);
|
||||
cJSON* type = cJSON_CreateString("alter");
|
||||
RAW_NULL_CHECK(type);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "type", type));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "type", type));
|
||||
cJSON* tableType = cJSON_CreateString(vAlterTbReq.action == TSDB_ALTER_TABLE_UPDATE_TAG_VAL ||
|
||||
vAlterTbReq.action == TSDB_ALTER_TABLE_UPDATE_MULTI_TAG_VAL
|
||||
? "child"
|
||||
: "normal");
|
||||
RAW_NULL_CHECK(tableType);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "tableType", tableType));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "tableType", tableType));
|
||||
cJSON* tableName = cJSON_CreateString(vAlterTbReq.tbName);
|
||||
RAW_NULL_CHECK(tableName);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "tableName", tableName));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "tableName", tableName));
|
||||
cJSON* alterType = cJSON_CreateNumber(vAlterTbReq.action);
|
||||
RAW_NULL_CHECK(alterType);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "alterType", alterType));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "alterType", alterType));
|
||||
|
||||
switch (vAlterTbReq.action) {
|
||||
case TSDB_ALTER_TABLE_ADD_COLUMN: {
|
||||
cJSON* colName = cJSON_CreateString(vAlterTbReq.colName);
|
||||
RAW_NULL_CHECK(colName);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colName", colName));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colName", colName));
|
||||
cJSON* colType = cJSON_CreateNumber(vAlterTbReq.type);
|
||||
RAW_NULL_CHECK(colType);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colType", colType));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colType", colType));
|
||||
|
||||
if (vAlterTbReq.type == TSDB_DATA_TYPE_BINARY || vAlterTbReq.type == TSDB_DATA_TYPE_VARBINARY ||
|
||||
vAlterTbReq.type == TSDB_DATA_TYPE_GEOMETRY) {
|
||||
int32_t length = vAlterTbReq.bytes - VARSTR_HEADER_SIZE;
|
||||
cJSON* cbytes = cJSON_CreateNumber(length);
|
||||
RAW_NULL_CHECK(cbytes);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colLength", cbytes));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colLength", cbytes));
|
||||
} else if (vAlterTbReq.type == TSDB_DATA_TYPE_NCHAR) {
|
||||
int32_t length = (vAlterTbReq.bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE;
|
||||
cJSON* cbytes = cJSON_CreateNumber(length);
|
||||
RAW_NULL_CHECK(cbytes);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colLength", cbytes));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colLength", cbytes));
|
||||
}
|
||||
break;
|
||||
}
|
||||
case TSDB_ALTER_TABLE_ADD_COLUMN_WITH_COMPRESS_OPTION: {
|
||||
cJSON* colName = cJSON_CreateString(vAlterTbReq.colName);
|
||||
RAW_NULL_CHECK(colName);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colName", colName));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colName", colName));
|
||||
cJSON* colType = cJSON_CreateNumber(vAlterTbReq.type);
|
||||
RAW_NULL_CHECK(colType);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colType", colType));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colType", colType));
|
||||
|
||||
if (vAlterTbReq.type == TSDB_DATA_TYPE_BINARY || vAlterTbReq.type == TSDB_DATA_TYPE_VARBINARY ||
|
||||
vAlterTbReq.type == TSDB_DATA_TYPE_GEOMETRY) {
|
||||
int32_t length = vAlterTbReq.bytes - VARSTR_HEADER_SIZE;
|
||||
cJSON* cbytes = cJSON_CreateNumber(length);
|
||||
RAW_NULL_CHECK(cbytes);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colLength", cbytes));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colLength", cbytes));
|
||||
} else if (vAlterTbReq.type == TSDB_DATA_TYPE_NCHAR) {
|
||||
int32_t length = (vAlterTbReq.bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE;
|
||||
cJSON* cbytes = cJSON_CreateNumber(length);
|
||||
RAW_NULL_CHECK(cbytes);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colLength", cbytes));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colLength", cbytes));
|
||||
}
|
||||
RAW_RETURN_CHECK(setCompressOption(json, vAlterTbReq.compress));
|
||||
break;
|
||||
|
|
@ -682,43 +694,43 @@ static void processAlterTable(SMqMetaRsp* metaRsp, cJSON** pJson) {
|
|||
case TSDB_ALTER_TABLE_DROP_COLUMN: {
|
||||
cJSON* colName = cJSON_CreateString(vAlterTbReq.colName);
|
||||
RAW_NULL_CHECK(colName);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colName", colName));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colName", colName));
|
||||
break;
|
||||
}
|
||||
case TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES: {
|
||||
cJSON* colName = cJSON_CreateString(vAlterTbReq.colName);
|
||||
RAW_NULL_CHECK(colName);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colName", colName));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colName", colName));
|
||||
cJSON* colType = cJSON_CreateNumber(vAlterTbReq.colModType);
|
||||
RAW_NULL_CHECK(colType);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colType", colType));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colType", colType));
|
||||
if (vAlterTbReq.colModType == TSDB_DATA_TYPE_BINARY || vAlterTbReq.colModType == TSDB_DATA_TYPE_VARBINARY ||
|
||||
vAlterTbReq.colModType == TSDB_DATA_TYPE_GEOMETRY) {
|
||||
int32_t length = vAlterTbReq.colModBytes - VARSTR_HEADER_SIZE;
|
||||
cJSON* cbytes = cJSON_CreateNumber(length);
|
||||
RAW_NULL_CHECK(cbytes);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colLength", cbytes));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colLength", cbytes));
|
||||
} else if (vAlterTbReq.colModType == TSDB_DATA_TYPE_NCHAR) {
|
||||
int32_t length = (vAlterTbReq.colModBytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE;
|
||||
cJSON* cbytes = cJSON_CreateNumber(length);
|
||||
RAW_NULL_CHECK(cbytes);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colLength", cbytes));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colLength", cbytes));
|
||||
}
|
||||
break;
|
||||
}
|
||||
case TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME: {
|
||||
cJSON* colName = cJSON_CreateString(vAlterTbReq.colName);
|
||||
RAW_NULL_CHECK(colName);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colName", colName));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colName", colName));
|
||||
cJSON* colNewName = cJSON_CreateString(vAlterTbReq.colNewName);
|
||||
RAW_NULL_CHECK(colNewName);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colNewName", colNewName));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colNewName", colNewName));
|
||||
break;
|
||||
}
|
||||
case TSDB_ALTER_TABLE_UPDATE_TAG_VAL: {
|
||||
cJSON* tagName = cJSON_CreateString(vAlterTbReq.tagName);
|
||||
RAW_NULL_CHECK(tagName);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colName", tagName));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colName", tagName));
|
||||
|
||||
bool isNull = vAlterTbReq.isNull;
|
||||
if (vAlterTbReq.tagType == TSDB_DATA_TYPE_JSON) {
|
||||
|
|
@ -757,12 +769,12 @@ static void processAlterTable(SMqMetaRsp* metaRsp, cJSON** pJson) {
|
|||
cJSON* colValue = cJSON_CreateString(buf);
|
||||
taosMemoryFree(buf);
|
||||
RAW_NULL_CHECK(colValue);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colValue", colValue));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colValue", colValue));
|
||||
}
|
||||
|
||||
cJSON* isNullCJson = cJSON_CreateBool(isNull);
|
||||
RAW_NULL_CHECK(isNullCJson);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colValueNull", isNullCJson));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colValueNull", isNullCJson));
|
||||
break;
|
||||
}
|
||||
case TSDB_ALTER_TABLE_UPDATE_MULTI_TAG_VAL: {
|
||||
|
|
@ -774,14 +786,17 @@ static void processAlterTable(SMqMetaRsp* metaRsp, cJSON** pJson) {
|
|||
|
||||
cJSON* tags = cJSON_CreateArray();
|
||||
RAW_NULL_CHECK(tags);
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "tags", tags));
|
||||
|
||||
for (int32_t i = 0; i < nTags; i++) {
|
||||
cJSON* member = cJSON_CreateObject();
|
||||
RAW_NULL_CHECK(member);
|
||||
RAW_FALSE_CHECK(tmqAddJsonArrayItem(tags, member));
|
||||
|
||||
SMultiTagUpateVal* pTagVal = taosArrayGet(vAlterTbReq.pMultiTag, i);
|
||||
cJSON* tagName = cJSON_CreateString(pTagVal->tagName);
|
||||
RAW_NULL_CHECK(tagName);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(member, "colName", tagName));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(member, "colName", tagName));
|
||||
|
||||
if (pTagVal->tagType == TSDB_DATA_TYPE_JSON) {
|
||||
uError("processAlterTable isJson false");
|
||||
|
|
@ -789,14 +804,13 @@ static void processAlterTable(SMqMetaRsp* metaRsp, cJSON** pJson) {
|
|||
}
|
||||
bool isNull = pTagVal->isNull;
|
||||
if (!isNull) {
|
||||
char* buf = NULL;
|
||||
int64_t bufSize = 0;
|
||||
if (pTagVal->tagType == TSDB_DATA_TYPE_VARBINARY) {
|
||||
bufSize = pTagVal->nTagVal * 2 + 2 + 3;
|
||||
} else {
|
||||
bufSize = pTagVal->nTagVal + 3;
|
||||
}
|
||||
buf = taosMemoryCalloc(bufSize, 1);
|
||||
char* buf = taosMemoryCalloc(bufSize, 1);
|
||||
RAW_NULL_CHECK(buf);
|
||||
if (dataConverToStr(buf, bufSize, pTagVal->tagType, pTagVal->pTagVal, pTagVal->nTagVal, NULL) !=
|
||||
TSDB_CODE_SUCCESS) {
|
||||
|
|
@ -806,21 +820,19 @@ static void processAlterTable(SMqMetaRsp* metaRsp, cJSON** pJson) {
|
|||
cJSON* colValue = cJSON_CreateString(buf);
|
||||
taosMemoryFree(buf);
|
||||
RAW_NULL_CHECK(colValue);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(member, "colValue", colValue));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(member, "colValue", colValue));
|
||||
}
|
||||
cJSON* isNullCJson = cJSON_CreateBool(isNull);
|
||||
RAW_NULL_CHECK(isNullCJson);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(member, "colValueNull", isNullCJson));
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToArray(tags, member));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(member, "colValueNull", isNullCJson));
|
||||
}
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "tags", tags));
|
||||
break;
|
||||
}
|
||||
|
||||
case TSDB_ALTER_TABLE_UPDATE_COLUMN_COMPRESS: {
|
||||
cJSON* colName = cJSON_CreateString(vAlterTbReq.colName);
|
||||
RAW_NULL_CHECK(colName);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "colName", colName));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "colName", colName));
|
||||
RAW_RETURN_CHECK(setCompressOption(json, vAlterTbReq.compress));
|
||||
break;
|
||||
}
|
||||
|
|
@ -858,13 +870,13 @@ static void processDropSTable(SMqMetaRsp* metaRsp, cJSON** pJson) {
|
|||
RAW_NULL_CHECK(json);
|
||||
cJSON* type = cJSON_CreateString("drop");
|
||||
RAW_NULL_CHECK(type);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "type", type));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "type", type));
|
||||
cJSON* tableType = cJSON_CreateString("super");
|
||||
RAW_NULL_CHECK(tableType);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "tableType", tableType));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "tableType", tableType));
|
||||
cJSON* tableName = cJSON_CreateString(req.name);
|
||||
RAW_NULL_CHECK(tableName);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "tableName", tableName));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "tableName", tableName));
|
||||
|
||||
end:
|
||||
uDebug("processDropSTable return");
|
||||
|
|
@ -897,10 +909,10 @@ static void processDeleteTable(SMqMetaRsp* metaRsp, cJSON** pJson) {
|
|||
RAW_NULL_CHECK(json);
|
||||
cJSON* type = cJSON_CreateString("delete");
|
||||
RAW_NULL_CHECK(type);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "type", type));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "type", type));
|
||||
cJSON* sqlJson = cJSON_CreateString(sql);
|
||||
RAW_NULL_CHECK(sqlJson);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "sql", sqlJson));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "sql", sqlJson));
|
||||
|
||||
end:
|
||||
uDebug("processDeleteTable return");
|
||||
|
|
@ -928,16 +940,17 @@ static void processDropTable(SMqMetaRsp* metaRsp, cJSON** pJson) {
|
|||
RAW_NULL_CHECK(json);
|
||||
cJSON* type = cJSON_CreateString("drop");
|
||||
RAW_NULL_CHECK(type);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "type", type));
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "type", type));
|
||||
cJSON* tableNameList = cJSON_CreateArray();
|
||||
RAW_NULL_CHECK(tableNameList);
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(json, "tableNameList", tableNameList));
|
||||
|
||||
for (int32_t iReq = 0; iReq < req.nReqs; iReq++) {
|
||||
SVDropTbReq* pDropTbReq = req.pReqs + iReq;
|
||||
cJSON* tableName = cJSON_CreateString(pDropTbReq->name);
|
||||
RAW_NULL_CHECK(tableName);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToArray(tableNameList, tableName));
|
||||
RAW_FALSE_CHECK(tmqAddJsonArrayItem(tableNameList, tableName));
|
||||
}
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "tableNameList", tableNameList));
|
||||
|
||||
end:
|
||||
uDebug("processDropTable return");
|
||||
|
|
@ -2183,6 +2196,8 @@ static void processBatchMetaToJson(SMqBatchMetaRsp* pMsgRsp, char** string) {
|
|||
RAW_FALSE_CHECK(cJSON_AddStringToObject(pJson, "tmq_meta_version", TMQ_META_VERSION));
|
||||
cJSON* pMetaArr = cJSON_CreateArray();
|
||||
RAW_NULL_CHECK(pMetaArr);
|
||||
RAW_FALSE_CHECK(tmqAddJsonObjectItem(pJson, "metas", pMetaArr));
|
||||
|
||||
int32_t num = taosArrayGetSize(rsp.batchMetaReq);
|
||||
for (int32_t i = 0; i < num; i++) {
|
||||
int32_t* len = taosArrayGet(rsp.batchMetaLen, i);
|
||||
|
|
@ -2198,10 +2213,9 @@ static void processBatchMetaToJson(SMqBatchMetaRsp* pMsgRsp, char** string) {
|
|||
cJSON* pItem = NULL;
|
||||
processSimpleMeta(&metaRsp, &pItem);
|
||||
tDeleteMqMetaRsp(&metaRsp);
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToArray(pMetaArr, pItem));
|
||||
RAW_FALSE_CHECK(tmqAddJsonArrayItem(pMetaArr, pItem));
|
||||
}
|
||||
|
||||
RAW_FALSE_CHECK(cJSON_AddItemToObject(pJson, "metas", pMetaArr));
|
||||
tDeleteMqBatchMetaRsp(&rsp);
|
||||
char* fullStr = cJSON_PrintUnformatted(pJson);
|
||||
cJSON_Delete(pJson);
|
||||
|
|
|
|||
|
|
@ -797,7 +797,7 @@ static int32_t mndGetStreamNameFromSmaName(char *streamName, char *smaName) {
|
|||
if (TSDB_CODE_SUCCESS != code) {
|
||||
return code;
|
||||
}
|
||||
sprintf(streamName, "%d.%s", n.acctId, n.tname);
|
||||
snprintf(streamName, TSDB_TABLE_FNAME_LEN,"%d.%s", n.acctId, n.tname);
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
|
|
@ -1222,7 +1222,7 @@ static int32_t mndGetSma(SMnode *pMnode, SUserIndexReq *indexReq, SUserIndexRsp
|
|||
|
||||
memcpy(rsp->dbFName, pSma->db, sizeof(pSma->db));
|
||||
memcpy(rsp->tblFName, pSma->stb, sizeof(pSma->stb));
|
||||
strcpy(rsp->indexType, TSDB_INDEX_TYPE_SMA);
|
||||
tstrncpy(rsp->indexType, TSDB_INDEX_TYPE_SMA, TSDB_INDEX_TYPE_LEN);
|
||||
|
||||
SNodeList *pList = NULL;
|
||||
int32_t extOffset = 0;
|
||||
|
|
@ -1255,8 +1255,8 @@ int32_t mndGetTableSma(SMnode *pMnode, char *tbFName, STableIndexRsp *rsp, bool
|
|||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
strcpy(rsp->dbFName, pStb->db);
|
||||
strcpy(rsp->tbName, pStb->name + strlen(pStb->db) + 1);
|
||||
tstrncpy(rsp->dbFName, pStb->db, TSDB_DB_FNAME_LEN);
|
||||
tstrncpy(rsp->tbName, pStb->name + strlen(pStb->db) + 1, TSDB_TABLE_NAME_LEN);
|
||||
rsp->suid = pStb->uid;
|
||||
rsp->version = pStb->smaVer;
|
||||
mndReleaseStb(pMnode, pStb);
|
||||
|
|
@ -1632,7 +1632,7 @@ static int32_t mndCreateTSMABuildCreateStreamReq(SCreateTSMACxt *pCxt) {
|
|||
f.bytes = pExprNode->resType.bytes;
|
||||
f.type = pExprNode->resType.type;
|
||||
f.flags = COL_SMA_ON;
|
||||
strcpy(f.name, pExprNode->userAlias);
|
||||
tstrncpy(f.name, pExprNode->userAlias, TSDB_COL_NAME_LEN);
|
||||
if (NULL == taosArrayPush(pCxt->pCreateStreamReq->pCols, &f)) {
|
||||
code = terrno;
|
||||
break;
|
||||
|
|
@ -1735,7 +1735,7 @@ static int32_t mndCreateTSMATxnPrepare(SCreateTSMACxt* pCxt) {
|
|||
}
|
||||
|
||||
dropStbReq.igNotExists = true;
|
||||
strncpy(dropStbReq.name, pCxt->targetStbFullName, TSDB_TABLE_FNAME_LEN);
|
||||
tstrncpy(dropStbReq.name, pCxt->targetStbFullName, TSDB_TABLE_FNAME_LEN);
|
||||
dropStbUndoAction.epSet = createStreamRedoAction.epSet;
|
||||
dropStbUndoAction.acceptableCode = TSDB_CODE_MND_STB_NOT_EXIST;
|
||||
dropStbUndoAction.retryCode = TSDB_CODE_MND_STREAM_MUST_BE_DELETED;
|
||||
|
|
@ -1836,7 +1836,7 @@ static int32_t mndTSMAGenerateOutputName(const char* tsmaName, char* streamName,
|
|||
if (TSDB_CODE_SUCCESS != code) {
|
||||
return code;
|
||||
}
|
||||
sprintf(streamName, "%d.%s", smaName.acctId, smaName.tname);
|
||||
snprintf(streamName, TSDB_TABLE_FNAME_LEN, "%d.%s", smaName.acctId, smaName.tname);
|
||||
snprintf(targetStbName, TSDB_TABLE_FNAME_LEN, "%s"TSMA_RES_STB_POSTFIX, tsmaName);
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
|
@ -2486,7 +2486,7 @@ static int32_t mndGetSomeTsmas(SMnode* pMnode, STableTSMAInfoRsp* pRsp, tsmaFilt
|
|||
mndReleaseStb(pMnode, pStb);
|
||||
TAOS_RETURN(code);
|
||||
}
|
||||
sprintf(streamName, "%d.%s", smaName.acctId, smaName.tname);
|
||||
snprintf(streamName, TSDB_TABLE_FNAME_LEN, "%d.%s", smaName.acctId, smaName.tname);
|
||||
pStream = NULL;
|
||||
|
||||
code = mndAcquireStream(pMnode, streamName, &pStream);
|
||||
|
|
|
|||
|
|
@ -1931,11 +1931,6 @@ static int32_t mndProcessVgroupChange(SMnode *pMnode, SVgroupChangeInfo *pChange
|
|||
sdbCancelFetch(pSdb, pIter);
|
||||
return terrno = code;
|
||||
}
|
||||
|
||||
code = mndStreamRegisterTrans(pTrans, MND_STREAM_TASK_UPDATE_NAME, pStream->uid);
|
||||
if (code) {
|
||||
mError("failed to register trans, transId:%d, and continue", pTrans->id);
|
||||
}
|
||||
}
|
||||
|
||||
if (!includeAllNodes) {
|
||||
|
|
@ -1951,6 +1946,12 @@ static int32_t mndProcessVgroupChange(SMnode *pMnode, SVgroupChangeInfo *pChange
|
|||
mDebug("stream:0x%" PRIx64 " %s involved node changed, create update trans, transId:%d", pStream->uid,
|
||||
pStream->name, pTrans->id);
|
||||
|
||||
// NOTE: for each stream, we register one trans entry for task update
|
||||
code = mndStreamRegisterTrans(pTrans, MND_STREAM_TASK_UPDATE_NAME, pStream->uid);
|
||||
if (code) {
|
||||
mError("failed to register trans, transId:%d, and continue", pTrans->id);
|
||||
}
|
||||
|
||||
code = mndStreamSetUpdateEpsetAction(pMnode, pStream, pChangeInfo, pTrans);
|
||||
|
||||
// todo: not continue, drop all and retry again
|
||||
|
|
|
|||
|
|
@ -35,7 +35,11 @@ int32_t mndStreamClearFinishedTrans(SMnode *pMnode, int32_t *pNumOfActiveChkpt)
|
|||
size_t keyLen = 0;
|
||||
void *pIter = NULL;
|
||||
SArray *pList = taosArrayInit(4, sizeof(SKeyInfo));
|
||||
int32_t num = 0;
|
||||
int32_t numOfChkpt = 0;
|
||||
|
||||
if (pNumOfActiveChkpt != NULL) {
|
||||
*pNumOfActiveChkpt = 0;
|
||||
}
|
||||
|
||||
if (pList == NULL) {
|
||||
return terrno;
|
||||
|
|
@ -50,15 +54,15 @@ int32_t mndStreamClearFinishedTrans(SMnode *pMnode, int32_t *pNumOfActiveChkpt)
|
|||
void *pKey = taosHashGetKey(pEntry, &keyLen);
|
||||
// key is the name of src/dst db name
|
||||
SKeyInfo info = {.pKey = pKey, .keyLen = keyLen};
|
||||
mDebug("transId:%d %s startTs:%" PRId64 " cleared since finished", pEntry->transId, pEntry->name,
|
||||
pEntry->startTime);
|
||||
mDebug("transId:%d stream:0x%" PRIx64 " %s startTs:%" PRId64 " cleared since finished", pEntry->transId,
|
||||
pEntry->streamId, pEntry->name, pEntry->startTime);
|
||||
void* p = taosArrayPush(pList, &info);
|
||||
if (p == NULL) {
|
||||
return terrno;
|
||||
}
|
||||
} else {
|
||||
if (strcmp(pEntry->name, MND_STREAM_CHECKPOINT_NAME) == 0) {
|
||||
num++;
|
||||
numOfChkpt++;
|
||||
}
|
||||
mndReleaseTrans(pMnode, pTrans);
|
||||
}
|
||||
|
|
@ -78,48 +82,34 @@ int32_t mndStreamClearFinishedTrans(SMnode *pMnode, int32_t *pNumOfActiveChkpt)
|
|||
}
|
||||
}
|
||||
|
||||
mDebug("clear %d finished stream-trans, remained:%d, active checkpoint trans:%d", size,
|
||||
taosHashGetSize(execInfo.transMgmt.pDBTrans), num);
|
||||
mDebug("clear %d finished stream-trans, active trans:%d, active checkpoint trans:%d", size,
|
||||
taosHashGetSize(execInfo.transMgmt.pDBTrans), numOfChkpt);
|
||||
|
||||
taosArrayDestroy(pList);
|
||||
|
||||
if (pNumOfActiveChkpt != NULL) {
|
||||
*pNumOfActiveChkpt = num;
|
||||
*pNumOfActiveChkpt = numOfChkpt;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// * Transactions of different streams are not related. Here only check the conflict of transaction for a given stream.
|
||||
// For a given stream:
|
||||
// 1. checkpoint trans is conflict with any other trans except for the drop and reset trans.
|
||||
// 2. create/drop/reset/update trans are conflict with any other trans.
|
||||
int32_t mndStreamTransConflictCheck(SMnode *pMnode, int64_t streamId, const char *pTransName, bool lock) {
|
||||
if (lock) {
|
||||
streamMutexLock(&execInfo.lock);
|
||||
}
|
||||
|
||||
static int32_t doStreamTransConflictCheck(SMnode *pMnode, int64_t streamId, const char *pTransName) {
|
||||
int32_t num = taosHashGetSize(execInfo.transMgmt.pDBTrans);
|
||||
if (num <= 0) {
|
||||
if (lock) {
|
||||
streamMutexUnlock(&execInfo.lock);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
// if any task updates exist, any other stream trans are not allowed to be created
|
||||
int32_t code = mndStreamClearFinishedTrans(pMnode, NULL);
|
||||
if (code) {
|
||||
mError("failed to clear finish trans, code:%s", tstrerror(code));
|
||||
mError("failed to clear finish trans, code:%s, and continue", tstrerror(code));
|
||||
}
|
||||
|
||||
SStreamTransInfo *pEntry = taosHashGet(execInfo.transMgmt.pDBTrans, &streamId, sizeof(streamId));
|
||||
if (pEntry != NULL) {
|
||||
SStreamTransInfo tInfo = *pEntry;
|
||||
|
||||
if (lock) {
|
||||
streamMutexUnlock(&execInfo.lock);
|
||||
}
|
||||
|
||||
if (strcmp(tInfo.name, MND_STREAM_CHECKPOINT_NAME) == 0) {
|
||||
if ((strcmp(pTransName, MND_STREAM_DROP_NAME) != 0) && (strcmp(pTransName, MND_STREAM_TASK_RESET_NAME) != 0) &&
|
||||
(strcmp(pTransName, MND_STREAM_RESTART_NAME) != 0)) {
|
||||
|
|
@ -141,11 +131,25 @@ int32_t mndStreamTransConflictCheck(SMnode *pMnode, int64_t streamId, const char
|
|||
mDebug("stream:0x%" PRIx64 " no conflict trans existed, continue create trans", streamId);
|
||||
}
|
||||
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
// * Transactions of different streams are not related. Here only check the conflict of transaction for a given stream.
|
||||
// For a given stream:
|
||||
// 1. checkpoint trans is conflict with any other trans except for the drop and reset trans.
|
||||
// 2. create/drop/reset/update trans are conflict with any other trans.
|
||||
int32_t mndStreamTransConflictCheck(SMnode *pMnode, int64_t streamId, const char *pTransName, bool lock) {
|
||||
if (lock) {
|
||||
streamMutexLock(&execInfo.lock);
|
||||
}
|
||||
|
||||
int32_t code = doStreamTransConflictCheck(pMnode, streamId, pTransName);
|
||||
|
||||
if (lock) {
|
||||
streamMutexUnlock(&execInfo.lock);
|
||||
}
|
||||
|
||||
return 0;
|
||||
return code;
|
||||
}
|
||||
|
||||
int32_t mndStreamGetRelTrans(SMnode *pMnode, int64_t streamId) {
|
||||
|
|
|
|||
|
|
@ -52,10 +52,17 @@ static bool mndTransPerformCommitStage(SMnode *pMnode, STrans *pTrans, bool t
|
|||
static bool mndTransPerformRollbackStage(SMnode *pMnode, STrans *pTrans, bool topHalf);
|
||||
static bool mndTransPerformFinishStage(SMnode *pMnode, STrans *pTrans, bool topHalf);
|
||||
|
||||
static bool mndCannotExecuteTransAction(SMnode *pMnode, bool topHalf) {
|
||||
return (!pMnode->deploy && !mndIsLeader(pMnode)) || !topHalf;
|
||||
static inline bool mndTransIsInSyncContext(bool topHalf) { return !topHalf; }
|
||||
|
||||
static bool mndCannotExecuteTrans(SMnode *pMnode, bool topHalf) {
|
||||
bool isLeader = mndIsLeader(pMnode);
|
||||
bool ret = (!pMnode->deploy && !isLeader) || mndTransIsInSyncContext(topHalf);
|
||||
if (ret) mDebug("cannot execute trans action, deploy:%d, isLeader:%d, topHalf:%d", pMnode->deploy, isLeader, topHalf);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline char *mndStrExecutionContext(bool topHalf) { return topHalf ? "transContext" : "syncContext"; }
|
||||
|
||||
static void mndTransSendRpcRsp(SMnode *pMnode, STrans *pTrans);
|
||||
static int32_t mndProcessTransTimer(SRpcMsg *pReq);
|
||||
static int32_t mndProcessTtl(SRpcMsg *pReq);
|
||||
|
|
@ -1335,7 +1342,7 @@ static int32_t mndTransWriteSingleLog(SMnode *pMnode, STrans *pTrans, STransActi
|
|||
// execute in trans context
|
||||
static int32_t mndTransSendSingleMsg(SMnode *pMnode, STrans *pTrans, STransAction *pAction, bool topHalf) {
|
||||
if (pAction->msgSent) return 0;
|
||||
if (mndCannotExecuteTransAction(pMnode, topHalf)) {
|
||||
if (mndCannotExecuteTrans(pMnode, topHalf)) {
|
||||
TAOS_RETURN(TSDB_CODE_MND_TRANS_CTX_SWITCH);
|
||||
}
|
||||
|
||||
|
|
@ -1481,8 +1488,8 @@ static int32_t mndTransExecuteActions(SMnode *pMnode, STrans *pTrans, SArray *pA
|
|||
static int32_t mndTransExecuteRedoActions(SMnode *pMnode, STrans *pTrans, bool topHalf) {
|
||||
int32_t code = mndTransExecuteActions(pMnode, pTrans, pTrans->redoActions, topHalf);
|
||||
if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS && code != TSDB_CODE_MND_TRANS_CTX_SWITCH) {
|
||||
mError("trans:%d, failed to execute redoActions since:%s, code:0x%x, topHalf(TransContext):%d", pTrans->id,
|
||||
terrstr(), terrno, topHalf);
|
||||
mError("trans:%d, failed to execute redoActions since:%s, code:0x%x, in %s", pTrans->id, terrstr(), terrno,
|
||||
mndStrExecutionContext(topHalf));
|
||||
}
|
||||
return code;
|
||||
}
|
||||
|
|
@ -1490,8 +1497,8 @@ static int32_t mndTransExecuteRedoActions(SMnode *pMnode, STrans *pTrans, bool t
|
|||
static int32_t mndTransExecuteUndoActions(SMnode *pMnode, STrans *pTrans, bool topHalf) {
|
||||
int32_t code = mndTransExecuteActions(pMnode, pTrans, pTrans->undoActions, topHalf);
|
||||
if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS && code != TSDB_CODE_MND_TRANS_CTX_SWITCH) {
|
||||
mError("trans:%d, failed to execute undoActions since %s. topHalf(TransContext):%d", pTrans->id, terrstr(),
|
||||
topHalf);
|
||||
mError("trans:%d, failed to execute undoActions since %s. in %s", pTrans->id, terrstr(),
|
||||
mndStrExecutionContext(topHalf));
|
||||
}
|
||||
return code;
|
||||
}
|
||||
|
|
@ -1499,8 +1506,8 @@ static int32_t mndTransExecuteUndoActions(SMnode *pMnode, STrans *pTrans, bool t
|
|||
static int32_t mndTransExecuteCommitActions(SMnode *pMnode, STrans *pTrans, bool topHalf) {
|
||||
int32_t code = mndTransExecuteActions(pMnode, pTrans, pTrans->commitActions, topHalf);
|
||||
if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS && code != TSDB_CODE_MND_TRANS_CTX_SWITCH) {
|
||||
mError("trans:%d, failed to execute commitActions since %s. topHalf(TransContext):%d", pTrans->id, terrstr(),
|
||||
topHalf);
|
||||
mError("trans:%d, failed to execute commitActions since %s. in %s", pTrans->id, terrstr(),
|
||||
mndStrExecutionContext(topHalf));
|
||||
}
|
||||
return code;
|
||||
}
|
||||
|
|
@ -1520,7 +1527,7 @@ static int32_t mndTransExecuteActionsSerial(SMnode *pMnode, STrans *pTrans, SArr
|
|||
for (int32_t action = pTrans->actionPos; action < numOfActions; ++action) {
|
||||
STransAction *pAction = taosArrayGet(pActions, action);
|
||||
|
||||
mInfo("trans:%d, current action:%d, stage:%s, actionType(0:log,1:msg):%d", pTrans->id, pTrans->actionPos,
|
||||
mInfo("trans:%d, current action:%d, stage:%s, actionType(1:msg,2:log):%d", pTrans->id, pTrans->actionPos,
|
||||
mndTransStr(pAction->stage), pAction->actionType);
|
||||
|
||||
code = mndTransExecSingleAction(pMnode, pTrans, pAction, topHalf);
|
||||
|
|
@ -1551,11 +1558,11 @@ static int32_t mndTransExecuteActionsSerial(SMnode *pMnode, STrans *pTrans, SArr
|
|||
}
|
||||
mndSetTransLastAction(pTrans, pAction);
|
||||
|
||||
if (mndCannotExecuteTransAction(pMnode, topHalf)) {
|
||||
if (mndCannotExecuteTrans(pMnode, topHalf)) {
|
||||
pTrans->lastErrorNo = code;
|
||||
pTrans->code = code;
|
||||
mInfo("trans:%d, %s:%d, topHalf(TransContext):%d, not execute next action, code:%s", pTrans->id,
|
||||
mndTransStr(pAction->stage), action, topHalf, tstrerror(code));
|
||||
mInfo("trans:%d, %s:%d, cannot execute next action in %s, code:%s", pTrans->id, mndTransStr(pAction->stage),
|
||||
action, mndStrExecutionContext(topHalf), tstrerror(code));
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
@ -1656,20 +1663,21 @@ static bool mndTransPerformRedoActionStage(SMnode *pMnode, STrans *pTrans, bool
|
|||
code = mndTransExecuteRedoActions(pMnode, pTrans, topHalf);
|
||||
}
|
||||
|
||||
if (mndCannotExecuteTransAction(pMnode, topHalf)) {
|
||||
if (code != 0 && code != TSDB_CODE_MND_TRANS_CTX_SWITCH && mndTransIsInSyncContext(topHalf)) {
|
||||
pTrans->lastErrorNo = code;
|
||||
pTrans->code = code;
|
||||
bool continueExec = true;
|
||||
if (code != 0 && code != TSDB_CODE_MND_TRANS_CTX_SWITCH) {
|
||||
mInfo(
|
||||
"trans:%d, failed to execute, will retry redo action stage in 100 ms , in %s, "
|
||||
"continueExec:%d, code:%s",
|
||||
pTrans->id, mndStrExecutionContext(topHalf), continueExec, tstrerror(code));
|
||||
taosMsleep(100);
|
||||
continueExec = true;
|
||||
return true;
|
||||
} else {
|
||||
continueExec = false;
|
||||
if (mndCannotExecuteTrans(pMnode, topHalf)) {
|
||||
mInfo("trans:%d, cannot continue to execute redo action stage in %s, continueExec:%d, code:%s", pTrans->id,
|
||||
mndStrExecutionContext(topHalf), continueExec, tstrerror(code));
|
||||
return false;
|
||||
}
|
||||
mInfo("trans:%d, cannot execute redo action stage, topHalf(TransContext):%d, continueExec:%d, code:%s", pTrans->id,
|
||||
topHalf, continueExec, tstrerror(code));
|
||||
|
||||
return continueExec;
|
||||
}
|
||||
terrno = code;
|
||||
|
||||
|
|
@ -1712,9 +1720,9 @@ static bool mndTransPerformRedoActionStage(SMnode *pMnode, STrans *pTrans, bool
|
|||
return continueExec;
|
||||
}
|
||||
|
||||
// in trans context
|
||||
// execute in trans context
|
||||
static bool mndTransPerformCommitStage(SMnode *pMnode, STrans *pTrans, bool topHalf) {
|
||||
if (mndCannotExecuteTransAction(pMnode, topHalf)) return false;
|
||||
if (mndCannotExecuteTrans(pMnode, topHalf)) return false;
|
||||
|
||||
bool continueExec = true;
|
||||
int32_t code = mndTransCommit(pMnode, pTrans);
|
||||
|
|
@ -1768,7 +1776,7 @@ static bool mndTransPerformUndoActionStage(SMnode *pMnode, STrans *pTrans, bool
|
|||
code = mndTransExecuteUndoActions(pMnode, pTrans, topHalf);
|
||||
}
|
||||
|
||||
if (mndCannotExecuteTransAction(pMnode, topHalf)) return false;
|
||||
if (mndCannotExecuteTrans(pMnode, topHalf)) return false;
|
||||
terrno = code;
|
||||
|
||||
if (code == 0) {
|
||||
|
|
@ -1789,7 +1797,7 @@ static bool mndTransPerformUndoActionStage(SMnode *pMnode, STrans *pTrans, bool
|
|||
|
||||
// in trans context
|
||||
static bool mndTransPerformRollbackStage(SMnode *pMnode, STrans *pTrans, bool topHalf) {
|
||||
if (mndCannotExecuteTransAction(pMnode, topHalf)) return false;
|
||||
if (mndCannotExecuteTrans(pMnode, topHalf)) return false;
|
||||
|
||||
bool continueExec = true;
|
||||
int32_t code = mndTransRollback(pMnode, pTrans);
|
||||
|
|
@ -1806,8 +1814,9 @@ static bool mndTransPerformRollbackStage(SMnode *pMnode, STrans *pTrans, bool to
|
|||
return continueExec;
|
||||
}
|
||||
|
||||
// excute in trans context
|
||||
static bool mndTransPerformPreFinishStage(SMnode *pMnode, STrans *pTrans, bool topHalf) {
|
||||
if (mndCannotExecuteTransAction(pMnode, topHalf)) return false;
|
||||
if (mndCannotExecuteTrans(pMnode, topHalf)) return false;
|
||||
|
||||
bool continueExec = true;
|
||||
int32_t code = mndTransPreFinish(pMnode, pTrans);
|
||||
|
|
@ -1850,8 +1859,8 @@ void mndTransExecuteImp(SMnode *pMnode, STrans *pTrans, bool topHalf) {
|
|||
bool continueExec = true;
|
||||
|
||||
while (continueExec) {
|
||||
mInfo("trans:%d, continue to execute, stage:%s createTime:%" PRId64 " topHalf(TransContext):%d", pTrans->id,
|
||||
mndTransStr(pTrans->stage), pTrans->createdTime, topHalf);
|
||||
mInfo("trans:%d, continue to execute stage:%s in %s, createTime:%" PRId64 "", pTrans->id,
|
||||
mndTransStr(pTrans->stage), mndStrExecutionContext(topHalf), pTrans->createdTime);
|
||||
pTrans->lastExecTime = taosGetTimestampMs();
|
||||
switch (pTrans->stage) {
|
||||
case TRN_STAGE_PREPARE:
|
||||
|
|
|
|||
|
|
@ -254,11 +254,12 @@ static void tdRSmaTaskInit(SStreamMeta *pMeta, SRSmaInfoItem *pItem, SStreamTask
|
|||
}
|
||||
|
||||
static void tdRSmaTaskRemove(SStreamMeta *pMeta, int64_t streamId, int32_t taskId) {
|
||||
streamMetaWLock(pMeta);
|
||||
|
||||
int32_t code = streamMetaUnregisterTask(pMeta, streamId, taskId);
|
||||
if (code != 0) {
|
||||
smaError("vgId:%d, rsma task:%" PRIi64 ",%d drop failed since %s", pMeta->vgId, streamId, taskId, tstrerror(code));
|
||||
}
|
||||
streamMetaWLock(pMeta);
|
||||
int32_t numOfTasks = streamMetaGetNumOfTasks(pMeta);
|
||||
if (streamMetaCommit(pMeta) < 0) {
|
||||
// persist to disk
|
||||
|
|
|
|||
|
|
@ -1122,6 +1122,18 @@ _OVER:
|
|||
return code;
|
||||
}
|
||||
|
||||
// always return success to mnode
|
||||
//todo: handle failure of build and send msg to mnode
|
||||
static void doSendChkptSourceRsp(SStreamCheckpointSourceReq* pReq, SRpcHandleInfo* pRpcInfo, int32_t code,
|
||||
int32_t taskId) {
|
||||
SRpcMsg rsp = {0};
|
||||
int32_t ret = streamTaskBuildCheckpointSourceRsp(pReq, pRpcInfo, &rsp, code);
|
||||
if (ret) { // suppress the error in build checkpoint source rsp
|
||||
tqError("s-task:0x%x failed to build checkpoint-source rsp, code:%s", taskId, tstrerror(ret));
|
||||
}
|
||||
tmsgSendRsp(&rsp); // error occurs
|
||||
}
|
||||
|
||||
// no matter what kinds of error happened, make sure the mnode will receive the success execution code.
|
||||
int32_t tqProcessTaskCheckPointSourceReq(STQ* pTq, SRpcMsg* pMsg, SRpcMsg* pRsp) {
|
||||
int32_t vgId = TD_VID(pTq->pVnode);
|
||||
|
|
@ -1129,84 +1141,57 @@ int32_t tqProcessTaskCheckPointSourceReq(STQ* pTq, SRpcMsg* pMsg, SRpcMsg* pRsp)
|
|||
char* msg = POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead));
|
||||
int32_t len = pMsg->contLen - sizeof(SMsgHead);
|
||||
int32_t code = 0;
|
||||
SStreamCheckpointSourceReq req = {0};
|
||||
SDecoder decoder = {0};
|
||||
SStreamTask* pTask = NULL;
|
||||
int64_t checkpointId = 0;
|
||||
|
||||
// disable auto rsp to mnode
|
||||
pRsp->info.handle = NULL;
|
||||
|
||||
SStreamCheckpointSourceReq req = {0};
|
||||
SDecoder decoder;
|
||||
tDecoderInit(&decoder, (uint8_t*)msg, len);
|
||||
if (tDecodeStreamCheckpointSourceReq(&decoder, &req) < 0) {
|
||||
code = TSDB_CODE_MSG_DECODE_ERROR;
|
||||
tDecoderClear(&decoder);
|
||||
tqError("vgId:%d failed to decode checkpoint-source msg, code:%s", vgId, tstrerror(code));
|
||||
|
||||
SRpcMsg rsp = {0};
|
||||
int32_t ret = streamTaskBuildCheckpointSourceRsp(&req, &pMsg->info, &rsp, TSDB_CODE_SUCCESS);
|
||||
if (ret) { // suppress the error in build checkpointsource rsp
|
||||
tqError("s-task:0x%x failed to build checkpoint-source rsp, code:%s", req.taskId, tstrerror(code));
|
||||
doSendChkptSourceRsp(&req, &pMsg->info, TSDB_CODE_SUCCESS, req.taskId);
|
||||
return TSDB_CODE_SUCCESS; // always return success to mnode,
|
||||
}
|
||||
|
||||
tmsgSendRsp(&rsp); // error occurs
|
||||
return TSDB_CODE_SUCCESS; // always return success to mnode, todo: handle failure of build and send msg to mnode
|
||||
}
|
||||
tDecoderClear(&decoder);
|
||||
|
||||
if (!vnodeIsRoleLeader(pTq->pVnode)) {
|
||||
tqDebug("vgId:%d not leader, ignore checkpoint-source msg, s-task:0x%x", vgId, req.taskId);
|
||||
SRpcMsg rsp = {0};
|
||||
int32_t ret = streamTaskBuildCheckpointSourceRsp(&req, &pMsg->info, &rsp, TSDB_CODE_SUCCESS);
|
||||
if (ret) { // suppress the error in build checkpointsource rsp
|
||||
tqError("s-task:0x%x failed to build checkpoint-source rsp, code:%s", req.taskId, tstrerror(code));
|
||||
}
|
||||
|
||||
tmsgSendRsp(&rsp); // error occurs
|
||||
return TSDB_CODE_SUCCESS; // always return success to mnode, todo: handle failure of build and send msg to mnode
|
||||
doSendChkptSourceRsp(&req, &pMsg->info, TSDB_CODE_SUCCESS, req.taskId);
|
||||
return TSDB_CODE_SUCCESS; // always return success to mnode
|
||||
}
|
||||
|
||||
if (!pTq->pVnode->restored) {
|
||||
tqDebug("vgId:%d checkpoint-source msg received during restoring, checkpointId:%" PRId64
|
||||
", transId:%d s-task:0x%x ignore it",
|
||||
vgId, req.checkpointId, req.transId, req.taskId);
|
||||
SRpcMsg rsp = {0};
|
||||
int32_t ret = streamTaskBuildCheckpointSourceRsp(&req, &pMsg->info, &rsp, TSDB_CODE_SUCCESS);
|
||||
if (ret) { // suppress the error in build checkpointsource rsp
|
||||
tqError("s-task:0x%x failed to build checkpoint-source rsp, code:%s", req.taskId, tstrerror(code));
|
||||
doSendChkptSourceRsp(&req, &pMsg->info, TSDB_CODE_SUCCESS, req.taskId);
|
||||
return TSDB_CODE_SUCCESS; // always return success to mnode
|
||||
}
|
||||
|
||||
tmsgSendRsp(&rsp); // error occurs
|
||||
return TSDB_CODE_SUCCESS; // always return success to mnode, , todo: handle failure of build and send msg to mnode
|
||||
}
|
||||
|
||||
SStreamTask* pTask = NULL;
|
||||
code = streamMetaAcquireTask(pMeta, req.streamId, req.taskId, &pTask);
|
||||
if (pTask == NULL || code != 0) {
|
||||
tqError("vgId:%d failed to find s-task:0x%x, ignore checkpoint msg. checkpointId:%" PRId64
|
||||
" transId:%d it may have been destroyed",
|
||||
vgId, req.taskId, req.checkpointId, req.transId);
|
||||
SRpcMsg rsp = {0};
|
||||
int32_t ret = streamTaskBuildCheckpointSourceRsp(&req, &pMsg->info, &rsp, TSDB_CODE_SUCCESS);
|
||||
if (ret) { // suppress the error in build checkpointsource rsp
|
||||
tqError("s-task:%s failed to build checkpoint-source rsp, code:%s", pTask->id.idStr, tstrerror(code));
|
||||
}
|
||||
tmsgSendRsp(&rsp); // error occurs
|
||||
doSendChkptSourceRsp(&req, &pMsg->info, TSDB_CODE_SUCCESS, req.taskId);
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
if (pTask->status.downstreamReady != 1) {
|
||||
streamTaskSetFailedChkptInfo(pTask, req.transId, req.checkpointId); // record the latest failed checkpoint id
|
||||
// record the latest failed checkpoint id
|
||||
streamTaskSetFailedChkptInfo(pTask, req.transId, req.checkpointId);
|
||||
tqError("s-task:%s not ready for checkpoint, since downstream not ready, ignore this checkpointId:%" PRId64
|
||||
", transId:%d set it failed",
|
||||
pTask->id.idStr, req.checkpointId, req.transId);
|
||||
|
||||
streamMetaReleaseTask(pMeta, pTask);
|
||||
|
||||
SRpcMsg rsp = {0};
|
||||
int32_t ret = streamTaskBuildCheckpointSourceRsp(&req, &pMsg->info, &rsp, TSDB_CODE_SUCCESS);
|
||||
if (ret) { // suppress the error in build checkpointsource rsp
|
||||
tqError("s-task:%s failed to build checkpoint-source rsp, code:%s", pTask->id.idStr, tstrerror(code));
|
||||
}
|
||||
|
||||
tmsgSendRsp(&rsp); // error occurs
|
||||
doSendChkptSourceRsp(&req, &pMsg->info, TSDB_CODE_SUCCESS, req.taskId);
|
||||
return TSDB_CODE_SUCCESS; // todo retry handle error
|
||||
}
|
||||
|
||||
|
|
@ -1221,14 +1206,7 @@ int32_t tqProcessTaskCheckPointSourceReq(STQ* pTq, SRpcMsg* pMsg, SRpcMsg* pRsp)
|
|||
|
||||
streamMutexUnlock(&pTask->lock);
|
||||
streamMetaReleaseTask(pMeta, pTask);
|
||||
|
||||
SRpcMsg rsp = {0};
|
||||
int32_t ret = streamTaskBuildCheckpointSourceRsp(&req, &pMsg->info, &rsp, TSDB_CODE_SUCCESS);
|
||||
if (ret) { // suppress the error in build checkpointsource rsp
|
||||
tqError("s-task:%s failed to build checkpoint-source rsp, code:%s", pTask->id.idStr, tstrerror(code));
|
||||
}
|
||||
|
||||
tmsgSendRsp(&rsp); // error occurs
|
||||
doSendChkptSourceRsp(&req, &pMsg->info, TSDB_CODE_SUCCESS, req.taskId);
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
} else {
|
||||
|
|
@ -1240,7 +1218,6 @@ int32_t tqProcessTaskCheckPointSourceReq(STQ* pTq, SRpcMsg* pMsg, SRpcMsg* pRsp)
|
|||
|
||||
// check if the checkpoint msg already sent or not.
|
||||
if (status == TASK_STATUS__CK) {
|
||||
int64_t checkpointId = 0;
|
||||
streamTaskGetActiveCheckpointInfo(pTask, NULL, &checkpointId);
|
||||
|
||||
tqWarn("s-task:%s repeatly recv checkpoint-source msg checkpointId:%" PRId64
|
||||
|
|
@ -1249,7 +1226,7 @@ int32_t tqProcessTaskCheckPointSourceReq(STQ* pTq, SRpcMsg* pMsg, SRpcMsg* pRsp)
|
|||
|
||||
streamMutexUnlock(&pTask->lock);
|
||||
streamMetaReleaseTask(pMeta, pTask);
|
||||
|
||||
doSendChkptSourceRsp(&req, &pMsg->info, TSDB_CODE_SYN_PROPOSE_NOT_READY, req.taskId);
|
||||
return TSDB_CODE_SUCCESS;
|
||||
} else { // checkpoint already finished, and not in checkpoint status
|
||||
if (req.checkpointId <= pTask->chkInfo.checkpointId) {
|
||||
|
|
@ -1259,15 +1236,7 @@ int32_t tqProcessTaskCheckPointSourceReq(STQ* pTq, SRpcMsg* pMsg, SRpcMsg* pRsp)
|
|||
|
||||
streamMutexUnlock(&pTask->lock);
|
||||
streamMetaReleaseTask(pMeta, pTask);
|
||||
|
||||
SRpcMsg rsp = {0};
|
||||
int32_t ret = streamTaskBuildCheckpointSourceRsp(&req, &pMsg->info, &rsp, TSDB_CODE_SUCCESS);
|
||||
if (ret) { // suppress the error in build checkpointsource rsp
|
||||
tqError("s-task:%s failed to build checkpoint-source rsp, code:%s", pTask->id.idStr, tstrerror(code));
|
||||
}
|
||||
|
||||
tmsgSendRsp(&rsp); // error occurs
|
||||
|
||||
doSendChkptSourceRsp(&req, &pMsg->info, TSDB_CODE_SUCCESS, req.taskId);
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
}
|
||||
|
|
@ -1278,7 +1247,9 @@ int32_t tqProcessTaskCheckPointSourceReq(STQ* pTq, SRpcMsg* pMsg, SRpcMsg* pRsp)
|
|||
if (code) {
|
||||
qError("s-task:%s (vgId:%d) failed to process checkpoint-source req, code:%s", pTask->id.idStr, vgId,
|
||||
tstrerror(code));
|
||||
return code;
|
||||
streamMetaReleaseTask(pMeta, pTask);
|
||||
doSendChkptSourceRsp(&req, &pMsg->info, TSDB_CODE_SUCCESS, req.taskId);
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
if (req.mndTrigger) {
|
||||
|
|
@ -1293,13 +1264,8 @@ int32_t tqProcessTaskCheckPointSourceReq(STQ* pTq, SRpcMsg* pMsg, SRpcMsg* pRsp)
|
|||
|
||||
code = streamAddCheckpointSourceRspMsg(&req, &pMsg->info, pTask);
|
||||
if (code != TSDB_CODE_SUCCESS) {
|
||||
SRpcMsg rsp = {0};
|
||||
int32_t ret = streamTaskBuildCheckpointSourceRsp(&req, &pMsg->info, &rsp, TSDB_CODE_SUCCESS);
|
||||
if (ret) { // suppress the error in build checkpointsource rsp
|
||||
tqError("s-task:%s failed to build checkpoint-source rsp, code:%s", pTask->id.idStr, tstrerror(code));
|
||||
}
|
||||
tmsgSendRsp(&rsp); // error occurs
|
||||
return TSDB_CODE_SUCCESS;
|
||||
streamTaskSetCheckpointFailed(pTask); // set the checkpoint failed
|
||||
doSendChkptSourceRsp(&req, &pMsg->info, TSDB_CODE_SUCCESS, req.taskId);
|
||||
}
|
||||
|
||||
streamMetaReleaseTask(pMeta, pTask);
|
||||
|
|
|
|||
|
|
@ -13,9 +13,7 @@
|
|||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <common/tmsg.h>
|
||||
#include "tcommon.h"
|
||||
#include "tmsg.h"
|
||||
#include "tq.h"
|
||||
|
||||
#define IS_NEW_SUBTB_RULE(_t) (((_t)->ver >= SSTREAM_TASK_SUBTABLE_CHANGED_VER) && ((_t)->subtableWithoutMd5 != 1))
|
||||
|
|
@ -50,7 +48,7 @@ static int32_t doPutSinkTableInfoIntoCache(SSHashObj* pSinkTableMap, STableSinkI
|
|||
static bool doGetSinkTableInfoFromCache(SSHashObj* pTableInfoMap, uint64_t groupId, STableSinkInfo** pInfo);
|
||||
static int32_t doRemoveSinkTableInfoInCache(SSHashObj* pSinkTableMap, uint64_t groupId, const char* id);
|
||||
static int32_t checkTagSchema(SStreamTask* pTask, SVnode* pVnode);
|
||||
static void reubuildAndSendMultiResBlock(SStreamTask* pTask, const SArray* pBlocks, SVnode* pVnode, int64_t earlyTs);
|
||||
static void rebuildAndSendMultiResBlock(SStreamTask* pTask, const SArray* pBlocks, SVnode* pVnode, int64_t earlyTs);
|
||||
static int32_t handleResultBlockMsg(SStreamTask* pTask, SSDataBlock* pDataBlock, int32_t index, SVnode* pVnode,
|
||||
int64_t earlyTs);
|
||||
static int32_t doWaitForDstTableDropped(SVnode* pVnode, SStreamTask* pTask, const char* dstTableName);
|
||||
|
|
@ -1187,7 +1185,7 @@ void tqSinkDataIntoDstTable(SStreamTask* pTask, void* vnode, void* data) {
|
|||
return;
|
||||
}
|
||||
|
||||
reubuildAndSendMultiResBlock(pTask, pBlocks, pVnode, earlyTs);
|
||||
rebuildAndSendMultiResBlock(pTask, pBlocks, pVnode, earlyTs);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1290,7 +1288,7 @@ int32_t doBuildAndSendDeleteMsg(SVnode* pVnode, char* stbFullName, SSDataBlock*
|
|||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
void reubuildAndSendMultiResBlock(SStreamTask* pTask, const SArray* pBlocks, SVnode* pVnode, int64_t earlyTs) {
|
||||
void rebuildAndSendMultiResBlock(SStreamTask* pTask, const SArray* pBlocks, SVnode* pVnode, int64_t earlyTs) {
|
||||
int32_t code = 0;
|
||||
const char* id = pTask->id.idStr;
|
||||
int32_t vgId = pTask->pMeta->vgId;
|
||||
|
|
|
|||
|
|
@ -17,19 +17,20 @@
|
|||
#include "vnd.h"
|
||||
|
||||
#define MAX_REPEAT_SCAN_THRESHOLD 3
|
||||
#define SCAN_WAL_IDLE_DURATION 100
|
||||
#define SCAN_WAL_IDLE_DURATION 500 // idle for 500ms to do next wal scan
|
||||
|
||||
typedef struct SBuildScanWalMsgParam {
|
||||
int64_t metaId;
|
||||
int32_t numOfTasks;
|
||||
} SBuildScanWalMsgParam;
|
||||
|
||||
static int32_t doScanWalForAllTasks(SStreamMeta* pStreamMeta, bool* pScanIdle);
|
||||
static int32_t doScanWalForAllTasks(SStreamMeta* pStreamMeta);
|
||||
static int32_t setWalReaderStartOffset(SStreamTask* pTask, int32_t vgId);
|
||||
static bool handleFillhistoryScanComplete(SStreamTask* pTask, int64_t ver);
|
||||
static bool taskReadyForDataFromWal(SStreamTask* pTask);
|
||||
static int32_t doPutDataIntoInputQ(SStreamTask* pTask, int64_t maxVer, int32_t* numOfItems, bool* pSucc);
|
||||
static int32_t tqScanWalInFuture(STQ* pTq, int32_t numOfTasks, int32_t idleDuration);
|
||||
static int32_t doScanWalAsync(STQ* pTq, bool ckPause);
|
||||
|
||||
// extract data blocks(submit/delete) from WAL, and add them into the input queue for all the sources tasks.
|
||||
int32_t tqScanWal(STQ* pTq) {
|
||||
|
|
@ -37,12 +38,11 @@ int32_t tqScanWal(STQ* pTq) {
|
|||
int32_t vgId = pMeta->vgId;
|
||||
int64_t st = taosGetTimestampMs();
|
||||
int32_t numOfTasks = 0;
|
||||
bool shouldIdle = true;
|
||||
|
||||
tqDebug("vgId:%d continue to check if data in wal are available, scanCounter:%d", vgId, pMeta->scanInfo.scanCounter);
|
||||
|
||||
// check all tasks
|
||||
int32_t code = doScanWalForAllTasks(pMeta, &shouldIdle);
|
||||
int32_t code = doScanWalForAllTasks(pMeta);
|
||||
if (code) {
|
||||
tqError("vgId:%d failed to start all tasks, try next time, code:%s", vgId, tstrerror(code));
|
||||
return code;
|
||||
|
|
@ -133,10 +133,9 @@ int32_t tqScanWalInFuture(STQ* pTq, int32_t numOfTasks, int32_t idleDuration) {
|
|||
}
|
||||
|
||||
int32_t tqScanWalAsync(STQ* pTq, bool ckPause) {
|
||||
int32_t vgId = TD_VID(pTq->pVnode);
|
||||
SStreamMeta* pMeta = pTq->pStreamMeta;
|
||||
bool alreadyRestored = pTq->pVnode->restored;
|
||||
int32_t numOfTasks = 0;
|
||||
int32_t code = 0;
|
||||
|
||||
// do not launch the stream tasks, if it is a follower or not restored vnode.
|
||||
if (!(vnodeIsRoleLeader(pTq->pVnode) && alreadyRestored)) {
|
||||
|
|
@ -144,47 +143,8 @@ int32_t tqScanWalAsync(STQ* pTq, bool ckPause) {
|
|||
}
|
||||
|
||||
streamMetaWLock(pMeta);
|
||||
|
||||
numOfTasks = taosArrayGetSize(pMeta->pTaskList);
|
||||
if (numOfTasks == 0) {
|
||||
tqDebug("vgId:%d no stream tasks existed to run", vgId);
|
||||
code = doScanWalAsync(pTq, ckPause);
|
||||
streamMetaWUnLock(pMeta);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (pMeta->startInfo.startAllTasks) {
|
||||
tqTrace("vgId:%d in restart procedure, not scan wal", vgId);
|
||||
streamMetaWUnLock(pMeta);
|
||||
return 0;
|
||||
}
|
||||
|
||||
pMeta->scanInfo.scanCounter += 1;
|
||||
if (pMeta->scanInfo.scanCounter > MAX_REPEAT_SCAN_THRESHOLD) {
|
||||
pMeta->scanInfo.scanCounter = MAX_REPEAT_SCAN_THRESHOLD;
|
||||
}
|
||||
|
||||
if (pMeta->scanInfo.scanCounter > 1) {
|
||||
tqDebug("vgId:%d wal read task has been launched, remain scan times:%d", vgId, pMeta->scanInfo.scanCounter);
|
||||
streamMetaWUnLock(pMeta);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int32_t numOfPauseTasks = pMeta->numOfPausedTasks;
|
||||
if (ckPause && numOfTasks == numOfPauseTasks) {
|
||||
tqDebug("vgId:%d ignore all submit, all streams had been paused, reset the walScanCounter", vgId);
|
||||
|
||||
// reset the counter value, since we do not launch the scan wal operation.
|
||||
pMeta->scanInfo.scanCounter = 0;
|
||||
streamMetaWUnLock(pMeta);
|
||||
return 0;
|
||||
}
|
||||
|
||||
tqDebug("vgId:%d create msg to start wal scan to launch stream tasks, numOfTasks:%d, vnd restored:%d", vgId,
|
||||
numOfTasks, alreadyRestored);
|
||||
|
||||
int32_t code = streamTaskSchedTask(&pTq->pVnode->msgCb, vgId, 0, 0, STREAM_EXEC_T_EXTRACT_WAL_DATA);
|
||||
streamMetaWUnLock(pMeta);
|
||||
|
||||
return code;
|
||||
}
|
||||
|
||||
|
|
@ -368,11 +328,8 @@ int32_t doPutDataIntoInputQ(SStreamTask* pTask, int64_t maxVer, int32_t* numOfIt
|
|||
return code;
|
||||
}
|
||||
|
||||
int32_t doScanWalForAllTasks(SStreamMeta* pStreamMeta, bool* pScanIdle) {
|
||||
*pScanIdle = true;
|
||||
bool noDataInWal = true;
|
||||
int32_t doScanWalForAllTasks(SStreamMeta* pStreamMeta) {
|
||||
int32_t vgId = pStreamMeta->vgId;
|
||||
|
||||
int32_t numOfTasks = taosArrayGetSize(pStreamMeta->pTaskList);
|
||||
if (numOfTasks == 0) {
|
||||
return TSDB_CODE_SUCCESS;
|
||||
|
|
@ -410,8 +367,6 @@ int32_t doScanWalForAllTasks(SStreamMeta* pStreamMeta, bool* pScanIdle) {
|
|||
continue;
|
||||
}
|
||||
|
||||
*pScanIdle = false;
|
||||
|
||||
// seek the stored version and extract data from WAL
|
||||
code = setWalReaderStartOffset(pTask, vgId);
|
||||
if (code != TSDB_CODE_SUCCESS) {
|
||||
|
|
@ -437,7 +392,6 @@ int32_t doScanWalForAllTasks(SStreamMeta* pStreamMeta, bool* pScanIdle) {
|
|||
streamMutexUnlock(&pTask->lock);
|
||||
|
||||
if ((numOfItems > 0) || hasNewData) {
|
||||
noDataInWal = false;
|
||||
code = streamTrySchedExec(pTask);
|
||||
if (code != TSDB_CODE_SUCCESS) {
|
||||
streamMetaReleaseTask(pStreamMeta, pTask);
|
||||
|
|
@ -449,11 +403,47 @@ int32_t doScanWalForAllTasks(SStreamMeta* pStreamMeta, bool* pScanIdle) {
|
|||
streamMetaReleaseTask(pStreamMeta, pTask);
|
||||
}
|
||||
|
||||
// all wal are checked, and no new data available in wal.
|
||||
if (noDataInWal) {
|
||||
*pScanIdle = true;
|
||||
}
|
||||
|
||||
taosArrayDestroy(pTaskList);
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
int32_t doScanWalAsync(STQ* pTq, bool ckPause) {
|
||||
SStreamMeta* pMeta = pTq->pStreamMeta;
|
||||
bool alreadyRestored = pTq->pVnode->restored;
|
||||
int32_t vgId = pMeta->vgId;
|
||||
int32_t numOfTasks = taosArrayGetSize(pMeta->pTaskList);
|
||||
|
||||
if (numOfTasks == 0) {
|
||||
tqDebug("vgId:%d no stream tasks existed to run", vgId);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (pMeta->startInfo.startAllTasks) {
|
||||
tqTrace("vgId:%d in restart procedure, not scan wal", vgId);
|
||||
return 0;
|
||||
}
|
||||
|
||||
pMeta->scanInfo.scanCounter += 1;
|
||||
if (pMeta->scanInfo.scanCounter > MAX_REPEAT_SCAN_THRESHOLD) {
|
||||
pMeta->scanInfo.scanCounter = MAX_REPEAT_SCAN_THRESHOLD;
|
||||
}
|
||||
|
||||
if (pMeta->scanInfo.scanCounter > 1) {
|
||||
tqDebug("vgId:%d wal read task has been launched, remain scan times:%d", vgId, pMeta->scanInfo.scanCounter);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int32_t numOfPauseTasks = pMeta->numOfPausedTasks;
|
||||
if (ckPause && numOfTasks == numOfPauseTasks) {
|
||||
tqDebug("vgId:%d ignore all submit, all streams had been paused, reset the walScanCounter", vgId);
|
||||
|
||||
// reset the counter value, since we do not launch the scan wal operation.
|
||||
pMeta->scanInfo.scanCounter = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
tqDebug("vgId:%d create msg to start wal scan to launch stream tasks, numOfTasks:%d, vnd restored:%d", vgId,
|
||||
numOfTasks, alreadyRestored);
|
||||
|
||||
return streamTaskSchedTask(&pTq->pVnode->msgCb, vgId, 0, 0, STREAM_EXEC_T_EXTRACT_WAL_DATA);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -718,8 +718,6 @@ int32_t tqStreamTaskProcessDropReq(SStreamMeta* pMeta, char* msg, int32_t msgLen
|
|||
}
|
||||
}
|
||||
|
||||
streamMetaWUnLock(pMeta);
|
||||
|
||||
// drop the related fill-history task firstly
|
||||
if (hTaskId.taskId != 0 && hTaskId.streamId != 0) {
|
||||
tqDebug("s-task:0x%x vgId:%d drop rel fill-history task:0x%x firstly", pReq->taskId, vgId, (int32_t)hTaskId.taskId);
|
||||
|
|
@ -737,7 +735,6 @@ int32_t tqStreamTaskProcessDropReq(SStreamMeta* pMeta, char* msg, int32_t msgLen
|
|||
}
|
||||
|
||||
// commit the update
|
||||
streamMetaWLock(pMeta);
|
||||
int32_t numOfTasks = streamMetaGetNumOfTasks(pMeta);
|
||||
tqDebug("vgId:%d task:0x%x dropped, remain tasks:%d", vgId, pReq->taskId, numOfTasks);
|
||||
|
||||
|
|
|
|||
|
|
@ -977,6 +977,11 @@ void vnodeUpdateMetaRsp(SVnode *pVnode, STableMetaRsp *pMetaRsp) {
|
|||
extern int32_t vnodeAsyncRetention(SVnode *pVnode, int64_t now);
|
||||
|
||||
static int32_t vnodeProcessTrimReq(SVnode *pVnode, int64_t ver, void *pReq, int32_t len, SRpcMsg *pRsp) {
|
||||
if (!pVnode->restored) {
|
||||
vInfo("vgId:%d, ignore trim req during restoring. ver:%" PRId64, TD_VID(pVnode), ver);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int32_t code = 0;
|
||||
SVTrimDbReq trimReq = {0};
|
||||
|
||||
|
|
|
|||
|
|
@ -987,7 +987,14 @@ _end:
|
|||
}
|
||||
|
||||
void resetStreamFillSup(SStreamFillSupporter* pFillSup) {
|
||||
_hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
|
||||
SSHashObj* pNewMap = tSimpleHashInit(16, hashFn);
|
||||
if (pNewMap != NULL) {
|
||||
tSimpleHashCleanup(pFillSup->pResMap);
|
||||
pFillSup->pResMap = pNewMap;
|
||||
} else {
|
||||
tSimpleHashClear(pFillSup->pResMap);
|
||||
}
|
||||
pFillSup->hasDelete = false;
|
||||
}
|
||||
void resetStreamFillInfo(SStreamFillOperatorInfo* pInfo) {
|
||||
|
|
@ -1406,6 +1413,7 @@ static int32_t doStreamForceFillNext(SOperatorInfo* pOperator, SSDataBlock** ppR
|
|||
}
|
||||
|
||||
pInfo->stateStore.streamStateClearExpiredState(pInfo->pState);
|
||||
resetStreamFillInfo(pInfo);
|
||||
setStreamOperatorCompleted(pOperator);
|
||||
(*ppRes) = NULL;
|
||||
goto _end;
|
||||
|
|
@ -1477,6 +1485,7 @@ static int32_t doStreamForceFillNext(SOperatorInfo* pOperator, SSDataBlock** ppR
|
|||
|
||||
if ((*ppRes) == NULL) {
|
||||
pInfo->stateStore.streamStateClearExpiredState(pInfo->pState);
|
||||
resetStreamFillInfo(pInfo);
|
||||
setStreamOperatorCompleted(pOperator);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -120,6 +120,36 @@ void initIntervalSlicePoint(SStreamAggSupporter* pAggSup, STimeWindow* pTWin, in
|
|||
pPoint->pLastRow = POINTER_SHIFT(pPoint->pFinished, sizeof(bool));
|
||||
}
|
||||
|
||||
int32_t getIntervalSlicePrevStateBuf(SStreamAggSupporter* pAggSup, SInterval* pInterval, SWinKey* pCurKey,
|
||||
SInervalSlicePoint* pPrevPoint) {
|
||||
int32_t code = TSDB_CODE_SUCCESS;
|
||||
int32_t lino = 0;
|
||||
SWinKey prevKey = {.groupId = pCurKey->groupId};
|
||||
SET_WIN_KEY_INVALID(prevKey.ts);
|
||||
int32_t prevVLen = 0;
|
||||
int32_t prevWinCode = TSDB_CODE_SUCCESS;
|
||||
code = pAggSup->stateStore.streamStateGetPrev(pAggSup->pState, pCurKey, &prevKey, (void**)&pPrevPoint->pResPos,
|
||||
&prevVLen, &prevWinCode);
|
||||
QUERY_CHECK_CODE(code, lino, _end);
|
||||
|
||||
if (prevWinCode == TSDB_CODE_SUCCESS) {
|
||||
STimeWindow prevSTW = {.skey = prevKey.ts};
|
||||
prevSTW.ekey = taosTimeGetIntervalEnd(prevSTW.skey, pInterval);
|
||||
initIntervalSlicePoint(pAggSup, &prevSTW, pCurKey->groupId, pPrevPoint);
|
||||
qDebug("===stream=== set stream twa prev point buf.ts:%" PRId64 ", groupId:%" PRIu64 ", res:%d",
|
||||
pPrevPoint->winKey.win.skey, pPrevPoint->winKey.groupId, prevWinCode);
|
||||
} else {
|
||||
SET_WIN_KEY_INVALID(pPrevPoint->winKey.win.skey);
|
||||
SET_WIN_KEY_INVALID(pPrevPoint->winKey.win.ekey);
|
||||
}
|
||||
|
||||
_end:
|
||||
if (code != TSDB_CODE_SUCCESS) {
|
||||
qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
|
||||
}
|
||||
return code;
|
||||
}
|
||||
|
||||
static int32_t getIntervalSliceCurStateBuf(SStreamAggSupporter* pAggSup, SInterval* pInterval, bool needPrev, STimeWindow* pTWin, int64_t groupId,
|
||||
SInervalSlicePoint* pCurPoint, SInervalSlicePoint* pPrevPoint, int32_t* pWinCode) {
|
||||
int32_t code = TSDB_CODE_SUCCESS;
|
||||
|
|
@ -136,24 +166,8 @@ static int32_t getIntervalSliceCurStateBuf(SStreamAggSupporter* pAggSup, SInterv
|
|||
initIntervalSlicePoint(pAggSup, pTWin, groupId, pCurPoint);
|
||||
|
||||
if (needPrev) {
|
||||
SWinKey prevKey = {.groupId = groupId};
|
||||
SET_WIN_KEY_INVALID(prevKey.ts);
|
||||
int32_t prevVLen = 0;
|
||||
int32_t prevWinCode = TSDB_CODE_SUCCESS;
|
||||
code = pAggSup->stateStore.streamStateGetPrev(pAggSup->pState, &curKey, &prevKey, (void**)&pPrevPoint->pResPos,
|
||||
&prevVLen, &prevWinCode);
|
||||
code = getIntervalSlicePrevStateBuf(pAggSup, pInterval, &curKey, pPrevPoint);
|
||||
QUERY_CHECK_CODE(code, lino, _end);
|
||||
|
||||
if (prevWinCode == TSDB_CODE_SUCCESS) {
|
||||
STimeWindow prevSTW = {.skey = prevKey.ts};
|
||||
prevSTW.ekey = taosTimeGetIntervalEnd(prevSTW.skey, pInterval);
|
||||
initIntervalSlicePoint(pAggSup, &prevSTW, groupId, pPrevPoint);
|
||||
qDebug("===stream=== set stream twa prev point buf.ts:%" PRId64 ", groupId:%" PRIu64 ", res:%d", pPrevPoint->winKey.win.skey,
|
||||
pPrevPoint->winKey.groupId, prevWinCode);
|
||||
} else {
|
||||
SET_WIN_KEY_INVALID(pPrevPoint->winKey.win.skey);
|
||||
SET_WIN_KEY_INVALID(pPrevPoint->winKey.win.ekey);
|
||||
}
|
||||
}
|
||||
|
||||
_end:
|
||||
|
|
@ -265,13 +279,15 @@ static int32_t doStreamIntervalSliceAggImpl(SOperatorInfo* pOperator, SSDataBloc
|
|||
STimeWindow curWin =
|
||||
getActiveTimeWindow(NULL, pResultRowInfo, curTs, &pInfo->interval, TSDB_ORDER_ASC);
|
||||
while (1) {
|
||||
if (curTs > pInfo->endTs) {
|
||||
break;
|
||||
}
|
||||
|
||||
int32_t winCode = TSDB_CODE_SUCCESS;
|
||||
if (curTs <= pInfo->endTs) {
|
||||
code = getIntervalSliceCurStateBuf(&pInfo->streamAggSup, &pInfo->interval, pInfo->hasInterpoFunc, &curWin, groupId, &curPoint, &prevPoint, &winCode);
|
||||
QUERY_CHECK_CODE(code, lino, _end);
|
||||
} else if (pInfo->hasInterpoFunc) {
|
||||
SWinKey curKey = {.ts = curWin.skey, .groupId = groupId};
|
||||
code = getIntervalSlicePrevStateBuf(&pInfo->streamAggSup, &pInfo->interval, &curKey, &prevPoint);
|
||||
QUERY_CHECK_CODE(code, lino, _end);
|
||||
}
|
||||
|
||||
if (pInfo->hasInterpoFunc && IS_VALID_WIN_KEY(prevPoint.winKey.win.skey) && isInterpoWindowFinished(&prevPoint) == false) {
|
||||
code = setIntervalSliceOutputBuf(&prevPoint, pSup->pCtx, numOfOutput, pSup->rowEntryInfoOffset);
|
||||
|
|
@ -288,6 +304,12 @@ static int32_t doStreamIntervalSliceAggImpl(SOperatorInfo* pOperator, SSDataBloc
|
|||
code = saveWinResult(&prevKey, prevPoint.pResPos, pInfo->pUpdatedMap);
|
||||
QUERY_CHECK_CODE(code, lino, _end);
|
||||
setInterpoWindowFinished(&prevPoint);
|
||||
} else if (IS_VALID_WIN_KEY(prevPoint.winKey.win.skey)) {
|
||||
releaseOutputBuf(pInfo->streamAggSup.pState, prevPoint.pResPos, &pInfo->streamAggSup.stateStore);
|
||||
}
|
||||
|
||||
if (curTs > pInfo->endTs) {
|
||||
break;
|
||||
}
|
||||
|
||||
code = setIntervalSliceOutputBuf(&curPoint, pSup->pCtx, numOfOutput, pSup->rowEntryInfoOffset);
|
||||
|
|
@ -300,7 +322,7 @@ static int32_t doStreamIntervalSliceAggImpl(SOperatorInfo* pOperator, SSDataBloc
|
|||
forwardRows = getNumOfRowsInTimeWindow(&pBlock->info, tsCols, startPos, curWin.ekey, binarySearchForKey, NULL,
|
||||
TSDB_ORDER_ASC);
|
||||
int32_t prevEndPos = (forwardRows - 1) + startPos;
|
||||
if (pInfo->hasInterpoFunc && winCode != TSDB_CODE_SUCCESS) {
|
||||
if (pInfo->hasInterpoFunc) {
|
||||
int32_t endRowId = getQualifiedRowNumDesc(pSup, pBlock, tsCols, prevEndPos, false);
|
||||
TSKEY endRowTs = tsCols[endRowId];
|
||||
transBlockToSliceResultRow(pBlock, endRowId, endRowTs, curPoint.pLastRow, 0, NULL, NULL, pInfo->pOffsetInfo);
|
||||
|
|
|
|||
|
|
@ -4952,7 +4952,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
|
|||
.paramInfoPattern = 0,
|
||||
.outputParaInfo = {.validDataType = FUNC_PARAM_SUPPORT_ALL_TYPE}},
|
||||
.translateFunc = translateSelectValue,
|
||||
.getEnvFunc = getSelectivityFuncEnv,
|
||||
.getEnvFunc = getGroupKeyFuncEnv,
|
||||
.initFunc = functionSetup,
|
||||
.processFunc = groupConstValueFunction,
|
||||
.finalizeFunc = groupConstValueFinalize,
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@
|
|||
|
||||
#define COPY_CHAR_ARRAY_FIELD(fldname) \
|
||||
do { \
|
||||
strcpy((pDst)->fldname, (pSrc)->fldname); \
|
||||
tstrncpy((pDst)->fldname, (pSrc)->fldname, sizeof((pDst)->fldname)); \
|
||||
} while (0)
|
||||
|
||||
#define COPY_OBJECT_FIELD(fldname, size) \
|
||||
|
|
|
|||
|
|
@ -2341,7 +2341,7 @@ char* nodesGetStrValueFromNode(SValueNode* pNode) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
sprintf(buf, "%s", pNode->datum.b ? "true" : "false");
|
||||
snprintf(buf, MAX_NUM_STR_SIZE, "%s", pNode->datum.b ? "true" : "false");
|
||||
return buf;
|
||||
}
|
||||
case TSDB_DATA_TYPE_TINYINT:
|
||||
|
|
@ -2354,7 +2354,7 @@ char* nodesGetStrValueFromNode(SValueNode* pNode) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
sprintf(buf, "%" PRId64, pNode->datum.i);
|
||||
snprintf(buf, MAX_NUM_STR_SIZE, "%" PRId64, pNode->datum.i);
|
||||
return buf;
|
||||
}
|
||||
case TSDB_DATA_TYPE_UTINYINT:
|
||||
|
|
@ -2366,7 +2366,7 @@ char* nodesGetStrValueFromNode(SValueNode* pNode) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
sprintf(buf, "%" PRIu64, pNode->datum.u);
|
||||
snprintf(buf, MAX_NUM_STR_SIZE, "%" PRIu64, pNode->datum.u);
|
||||
return buf;
|
||||
}
|
||||
case TSDB_DATA_TYPE_FLOAT:
|
||||
|
|
@ -2376,7 +2376,7 @@ char* nodesGetStrValueFromNode(SValueNode* pNode) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
sprintf(buf, "%e", pNode->datum.d);
|
||||
snprintf(buf, MAX_NUM_STR_SIZE, "%e", pNode->datum.d);
|
||||
return buf;
|
||||
}
|
||||
case TSDB_DATA_TYPE_NCHAR:
|
||||
|
|
@ -2532,7 +2532,7 @@ static EDealRes doCollect(SCollectColumnsCxt* pCxt, SColumnNode* pCol, SNode* pN
|
|||
}
|
||||
if (pCol->projRefIdx > 0) {
|
||||
len = taosHashBinary(name, strlen(name));
|
||||
len += sprintf(name + len, "_%d", pCol->projRefIdx);
|
||||
len += tsnprintf(name + len, TSDB_TABLE_NAME_LEN + TSDB_COL_NAME_LEN - len, "_%d", pCol->projRefIdx);
|
||||
}
|
||||
SNode** pNodeFound = taosHashGet(pCxt->pColHash, name, len);
|
||||
if (pNodeFound == NULL) {
|
||||
|
|
@ -2952,17 +2952,16 @@ int32_t nodesValueNodeToVariant(const SValueNode* pNode, SVariant* pVal) {
|
|||
case TSDB_DATA_TYPE_VARCHAR:
|
||||
case TSDB_DATA_TYPE_VARBINARY:
|
||||
case TSDB_DATA_TYPE_GEOMETRY:
|
||||
pVal->pz = taosMemoryMalloc(pVal->nLen + 1);
|
||||
pVal->pz = taosMemoryCalloc(1, pVal->nLen + 1);
|
||||
if (pVal->pz) {
|
||||
memcpy(pVal->pz, pNode->datum.p, pVal->nLen);
|
||||
pVal->pz[pVal->nLen] = 0;
|
||||
memcpy(pVal->pz, pNode->datum.p, varDataTLen(pNode->datum.p));
|
||||
} else {
|
||||
code = terrno;
|
||||
}
|
||||
break;
|
||||
case TSDB_DATA_TYPE_JSON:
|
||||
pVal->nLen = getJsonValueLen(pNode->datum.p);
|
||||
pVal->pz = taosMemoryMalloc(pVal->nLen);
|
||||
pVal->pz = taosMemoryCalloc(1, pVal->nLen);
|
||||
if (pVal->pz) {
|
||||
memcpy(pVal->pz, pNode->datum.p, pVal->nLen);
|
||||
} else {
|
||||
|
|
|
|||
|
|
@ -142,13 +142,13 @@ static int32_t parseEndpoint(SAstCreateContext* pCxt, const SToken* pEp, char* p
|
|||
(void)strdequote(ep);
|
||||
(void)strtrim(ep);
|
||||
if (NULL == pPort) {
|
||||
strcpy(pFqdn, ep);
|
||||
tstrncpy(pFqdn, ep, TSDB_FQDN_LEN);
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
char* pColon = strchr(ep, ':');
|
||||
if (NULL == pColon) {
|
||||
*pPort = tsServerPort;
|
||||
strcpy(pFqdn, ep);
|
||||
tstrncpy(pFqdn, ep, TSDB_FQDN_LEN);
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
strncpy(pFqdn, ep, pColon - ep);
|
||||
|
|
@ -320,12 +320,12 @@ SNode* releaseRawExprNode(SAstCreateContext* pCxt, SNode* pNode) {
|
|||
if (nodesIsExprNode(pRealizedExpr)) {
|
||||
SExprNode* pExpr = (SExprNode*)pRealizedExpr;
|
||||
if (QUERY_NODE_COLUMN == nodeType(pExpr)) {
|
||||
strcpy(pExpr->aliasName, ((SColumnNode*)pExpr)->colName);
|
||||
strcpy(pExpr->userAlias, ((SColumnNode*)pExpr)->colName);
|
||||
tstrncpy(pExpr->aliasName, ((SColumnNode*)pExpr)->colName, TSDB_COL_NAME_LEN);
|
||||
tstrncpy(pExpr->userAlias, ((SColumnNode*)pExpr)->colName, TSDB_COL_NAME_LEN);
|
||||
} else if (pRawExpr->isPseudoColumn) {
|
||||
// all pseudo column are translate to function with same name
|
||||
strcpy(pExpr->userAlias, ((SFunctionNode*)pExpr)->functionName);
|
||||
strcpy(pExpr->aliasName, ((SFunctionNode*)pExpr)->functionName);
|
||||
tstrncpy(pExpr->userAlias, ((SFunctionNode*)pExpr)->functionName, TSDB_COL_NAME_LEN);
|
||||
tstrncpy(pExpr->aliasName, ((SFunctionNode*)pExpr)->functionName, TSDB_COL_NAME_LEN);
|
||||
} else {
|
||||
int32_t len = TMIN(sizeof(pExpr->aliasName) - 1, pRawExpr->n);
|
||||
|
||||
|
|
@ -333,9 +333,9 @@ SNode* releaseRawExprNode(SAstCreateContext* pCxt, SNode* pNode) {
|
|||
// Len of pRawExpr->p could be larger than len of aliasName[TSDB_COL_NAME_LEN].
|
||||
// If aliasName is truncated, hash value of aliasName could be the same.
|
||||
uint64_t hashVal = MurmurHash3_64(pRawExpr->p, pRawExpr->n);
|
||||
sprintf(pExpr->aliasName, "%" PRIu64, hashVal);
|
||||
snprintf(pExpr->aliasName, TSDB_COL_NAME_LEN, "%" PRIu64, hashVal);
|
||||
strncpy(pExpr->userAlias, pRawExpr->p, len);
|
||||
pExpr->userAlias[len] = '\0';
|
||||
pExpr->userAlias[len] = 0;
|
||||
}
|
||||
}
|
||||
pRawExpr->pNode = NULL;
|
||||
|
|
@ -948,11 +948,11 @@ SNode* createOperatorNode(SAstCreateContext* pCxt, EOperatorType type, SNode* pL
|
|||
goto _err;
|
||||
}
|
||||
if ('+' == pVal->literal[0]) {
|
||||
sprintf(pNewLiteral, "-%s", pVal->literal + 1);
|
||||
snprintf(pNewLiteral, strlen(pVal->literal) + 2, "-%s", pVal->literal + 1);
|
||||
} else if ('-' == pVal->literal[0]) {
|
||||
sprintf(pNewLiteral, "%s", pVal->literal + 1);
|
||||
snprintf(pNewLiteral, strlen(pVal->literal) + 2, "%s", pVal->literal + 1);
|
||||
} else {
|
||||
sprintf(pNewLiteral, "-%s", pVal->literal);
|
||||
snprintf(pNewLiteral, strlen(pVal->literal) + 2, "-%s", pVal->literal);
|
||||
}
|
||||
taosMemoryFree(pVal->literal);
|
||||
pVal->literal = pNewLiteral;
|
||||
|
|
@ -1025,7 +1025,7 @@ static SNode* createPrimaryKeyCol(SAstCreateContext* pCxt, const SToken* pFuncNa
|
|||
CHECK_MAKE_NODE(pCol);
|
||||
pCol->colId = PRIMARYKEY_TIMESTAMP_COL_ID;
|
||||
if (NULL == pFuncName) {
|
||||
strcpy(pCol->colName, ROWTS_PSEUDO_COLUMN_NAME);
|
||||
tstrncpy(pCol->colName, ROWTS_PSEUDO_COLUMN_NAME, TSDB_COL_NAME_LEN);
|
||||
} else {
|
||||
strncpy(pCol->colName, pFuncName->z, pFuncName->n);
|
||||
}
|
||||
|
|
@ -1058,7 +1058,7 @@ SNode* createCastFunctionNode(SAstCreateContext* pCxt, SNode* pExpr, SDataType d
|
|||
CHECK_PARSER_STATUS(pCxt);
|
||||
pCxt->errCode = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&func);
|
||||
CHECK_MAKE_NODE(func);
|
||||
strcpy(func->functionName, "cast");
|
||||
tstrncpy(func->functionName, "cast", TSDB_FUNC_NAME_LEN);
|
||||
func->node.resType = dt;
|
||||
if (TSDB_DATA_TYPE_VARCHAR == dt.type || TSDB_DATA_TYPE_GEOMETRY == dt.type || TSDB_DATA_TYPE_VARBINARY == dt.type) {
|
||||
func->node.resType.bytes = func->node.resType.bytes + VARSTR_HEADER_SIZE;
|
||||
|
|
@ -1082,7 +1082,7 @@ SNode* createPositionFunctionNode(SAstCreateContext* pCxt, SNode* pExpr, SNode*
|
|||
CHECK_PARSER_STATUS(pCxt);
|
||||
pCxt->errCode = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&func);
|
||||
CHECK_MAKE_NODE(func);
|
||||
strcpy(func->functionName, "position");
|
||||
tstrncpy(func->functionName, "position", TSDB_FUNC_NAME_LEN);
|
||||
pCxt->errCode = nodesListMakeAppend(&func->pParameterList, pExpr);
|
||||
CHECK_PARSER_STATUS(pCxt);
|
||||
pCxt->errCode = nodesListMakeAppend(&func->pParameterList, pExpr2);
|
||||
|
|
@ -1100,7 +1100,7 @@ SNode* createTrimFunctionNode(SAstCreateContext* pCxt, SNode* pExpr, ETrimType t
|
|||
CHECK_PARSER_STATUS(pCxt);
|
||||
pCxt->errCode = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&func);
|
||||
CHECK_MAKE_NODE(func);
|
||||
strcpy(func->functionName, "trim");
|
||||
tstrncpy(func->functionName, "trim", TSDB_FUNC_NAME_LEN);
|
||||
func->trimType = type;
|
||||
pCxt->errCode = nodesListMakeAppend(&func->pParameterList, pExpr);
|
||||
CHECK_PARSER_STATUS(pCxt);
|
||||
|
|
@ -1117,7 +1117,7 @@ SNode* createTrimFunctionNodeExt(SAstCreateContext* pCxt, SNode* pExpr, SNode* p
|
|||
CHECK_PARSER_STATUS(pCxt);
|
||||
pCxt->errCode = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&func);
|
||||
CHECK_MAKE_NODE(func);
|
||||
strcpy(func->functionName, "trim");
|
||||
tstrncpy(func->functionName, "trim", TSDB_FUNC_NAME_LEN);
|
||||
func->trimType = type;
|
||||
pCxt->errCode = nodesListMakeAppend(&func->pParameterList, pExpr);
|
||||
CHECK_PARSER_STATUS(pCxt);
|
||||
|
|
@ -1137,7 +1137,7 @@ SNode* createSubstrFunctionNode(SAstCreateContext* pCxt, SNode* pExpr, SNode* pE
|
|||
CHECK_PARSER_STATUS(pCxt);
|
||||
pCxt->errCode = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&func);
|
||||
CHECK_MAKE_NODE(func);
|
||||
strcpy(func->functionName, "substr");
|
||||
tstrncpy(func->functionName, "substr", TSDB_FUNC_NAME_LEN);
|
||||
pCxt->errCode = nodesListMakeAppend(&func->pParameterList, pExpr);
|
||||
CHECK_PARSER_STATUS(pCxt);
|
||||
pCxt->errCode = nodesListMakeAppend(&func->pParameterList, pExpr2);
|
||||
|
|
@ -1155,7 +1155,7 @@ SNode* createSubstrFunctionNodeExt(SAstCreateContext* pCxt, SNode* pExpr, SNode*
|
|||
CHECK_PARSER_STATUS(pCxt);
|
||||
pCxt->errCode = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&func);
|
||||
CHECK_MAKE_NODE(func);
|
||||
strcpy(func->functionName, "substr");
|
||||
tstrncpy(func->functionName, "substr", TSDB_FUNC_NAME_LEN);
|
||||
pCxt->errCode = nodesListMakeAppend(&func->pParameterList, pExpr);
|
||||
CHECK_PARSER_STATUS(pCxt);
|
||||
pCxt->errCode = nodesListMakeAppend(&func->pParameterList, pExpr2);
|
||||
|
|
@ -1239,10 +1239,10 @@ SNode* createTempTableNode(SAstCreateContext* pCxt, SNode* pSubquery, SToken* pT
|
|||
taosRandStr(tempTable->table.tableAlias, 8);
|
||||
}
|
||||
if (QUERY_NODE_SELECT_STMT == nodeType(pSubquery)) {
|
||||
strcpy(((SSelectStmt*)pSubquery)->stmtName, tempTable->table.tableAlias);
|
||||
tstrncpy(((SSelectStmt*)pSubquery)->stmtName, tempTable->table.tableAlias, TSDB_TABLE_NAME_LEN);
|
||||
((SSelectStmt*)pSubquery)->isSubquery = true;
|
||||
} else if (QUERY_NODE_SET_OPERATOR == nodeType(pSubquery)) {
|
||||
strcpy(((SSetOperator*)pSubquery)->stmtName, tempTable->table.tableAlias);
|
||||
tstrncpy(((SSetOperator*)pSubquery)->stmtName, tempTable->table.tableAlias, TSDB_TABLE_NAME_LEN);
|
||||
}
|
||||
return (SNode*)tempTable;
|
||||
_err:
|
||||
|
|
@ -1447,7 +1447,7 @@ SNode* createFillNode(SAstCreateContext* pCxt, EFillMode mode, SNode* pValues) {
|
|||
fill->pWStartTs = NULL;
|
||||
pCxt->errCode = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&(fill->pWStartTs));
|
||||
CHECK_MAKE_NODE(fill->pWStartTs);
|
||||
strcpy(((SFunctionNode*)fill->pWStartTs)->functionName, "_wstart");
|
||||
tstrncpy(((SFunctionNode*)fill->pWStartTs)->functionName, "_wstart", TSDB_FUNC_NAME_LEN);
|
||||
return (SNode*)fill;
|
||||
_err:
|
||||
nodesDestroyNode((SNode*)fill);
|
||||
|
|
@ -1779,7 +1779,7 @@ SNode* createSetOperator(SAstCreateContext* pCxt, ESetOperatorType type, SNode*
|
|||
setSubquery(setOp->pLeft);
|
||||
setOp->pRight = pRight;
|
||||
setSubquery(setOp->pRight);
|
||||
sprintf(setOp->stmtName, "%p", setOp);
|
||||
snprintf(setOp->stmtName, TSDB_TABLE_NAME_LEN, "%p", setOp);
|
||||
return (SNode*)setOp;
|
||||
_err:
|
||||
nodesDestroyNode(pLeft);
|
||||
|
|
@ -2337,8 +2337,8 @@ SNode* createCreateTableStmt(SAstCreateContext* pCxt, bool ignoreExists, SNode*
|
|||
SCreateTableStmt* pStmt = NULL;
|
||||
pCxt->errCode = nodesMakeNode(QUERY_NODE_CREATE_TABLE_STMT, (SNode**)&pStmt);
|
||||
CHECK_MAKE_NODE(pStmt);
|
||||
strcpy(pStmt->dbName, ((SRealTableNode*)pRealTable)->table.dbName);
|
||||
strcpy(pStmt->tableName, ((SRealTableNode*)pRealTable)->table.tableName);
|
||||
tstrncpy(pStmt->dbName, ((SRealTableNode*)pRealTable)->table.dbName, TSDB_DB_NAME_LEN);
|
||||
tstrncpy(pStmt->tableName, ((SRealTableNode*)pRealTable)->table.tableName, TSDB_TABLE_NAME_LEN);
|
||||
pStmt->ignoreExists = ignoreExists;
|
||||
pStmt->pCols = pCols;
|
||||
pStmt->pTags = pTags;
|
||||
|
|
@ -2359,10 +2359,10 @@ SNode* createCreateSubTableClause(SAstCreateContext* pCxt, bool ignoreExists, SN
|
|||
SCreateSubTableClause* pStmt = NULL;
|
||||
pCxt->errCode = nodesMakeNode(QUERY_NODE_CREATE_SUBTABLE_CLAUSE, (SNode**)&pStmt);
|
||||
CHECK_MAKE_NODE(pStmt);
|
||||
strcpy(pStmt->dbName, ((SRealTableNode*)pRealTable)->table.dbName);
|
||||
strcpy(pStmt->tableName, ((SRealTableNode*)pRealTable)->table.tableName);
|
||||
strcpy(pStmt->useDbName, ((SRealTableNode*)pUseRealTable)->table.dbName);
|
||||
strcpy(pStmt->useTableName, ((SRealTableNode*)pUseRealTable)->table.tableName);
|
||||
tstrncpy(pStmt->dbName, ((SRealTableNode*)pRealTable)->table.dbName, TSDB_DB_NAME_LEN);
|
||||
tstrncpy(pStmt->tableName, ((SRealTableNode*)pRealTable)->table.tableName, TSDB_TABLE_NAME_LEN);
|
||||
tstrncpy(pStmt->useDbName, ((SRealTableNode*)pUseRealTable)->table.dbName, TSDB_DB_NAME_LEN);
|
||||
tstrncpy(pStmt->useTableName, ((SRealTableNode*)pUseRealTable)->table.tableName, TSDB_TABLE_NAME_LEN);
|
||||
pStmt->ignoreExists = ignoreExists;
|
||||
pStmt->pSpecificTags = pSpecificTags;
|
||||
pStmt->pValsOfTags = pValsOfTags;
|
||||
|
|
@ -2385,8 +2385,8 @@ SNode* createCreateSubTableFromFileClause(SAstCreateContext* pCxt, bool ignoreEx
|
|||
SCreateSubTableFromFileClause* pStmt = NULL;
|
||||
pCxt->errCode = nodesMakeNode(QUERY_NODE_CREATE_SUBTABLE_FROM_FILE_CLAUSE, (SNode**)&pStmt);
|
||||
CHECK_MAKE_NODE(pStmt);
|
||||
strcpy(pStmt->useDbName, ((SRealTableNode*)pUseRealTable)->table.dbName);
|
||||
strcpy(pStmt->useTableName, ((SRealTableNode*)pUseRealTable)->table.tableName);
|
||||
tstrncpy(pStmt->useDbName, ((SRealTableNode*)pUseRealTable)->table.dbName, TSDB_DB_NAME_LEN);
|
||||
tstrncpy(pStmt->useTableName, ((SRealTableNode*)pUseRealTable)->table.tableName, TSDB_TABLE_NAME_LEN);
|
||||
pStmt->ignoreExists = ignoreExists;
|
||||
pStmt->pSpecificTags = pSpecificTags;
|
||||
if (TK_NK_STRING == pFilePath->type) {
|
||||
|
|
@ -2420,8 +2420,8 @@ SNode* createDropTableClause(SAstCreateContext* pCxt, bool ignoreNotExists, SNod
|
|||
SDropTableClause* pStmt = NULL;
|
||||
pCxt->errCode = nodesMakeNode(QUERY_NODE_DROP_TABLE_CLAUSE, (SNode**)&pStmt);
|
||||
CHECK_MAKE_NODE(pStmt);
|
||||
strcpy(pStmt->dbName, ((SRealTableNode*)pRealTable)->table.dbName);
|
||||
strcpy(pStmt->tableName, ((SRealTableNode*)pRealTable)->table.tableName);
|
||||
tstrncpy(pStmt->dbName, ((SRealTableNode*)pRealTable)->table.dbName, TSDB_DB_NAME_LEN);
|
||||
tstrncpy(pStmt->tableName, ((SRealTableNode*)pRealTable)->table.tableName, TSDB_TABLE_NAME_LEN);
|
||||
pStmt->ignoreNotExists = ignoreNotExists;
|
||||
nodesDestroyNode(pRealTable);
|
||||
return (SNode*)pStmt;
|
||||
|
|
@ -2448,8 +2448,8 @@ SNode* createDropSuperTableStmt(SAstCreateContext* pCxt, bool withOpt, bool igno
|
|||
SDropSuperTableStmt* pStmt = NULL;
|
||||
pCxt->errCode = nodesMakeNode(QUERY_NODE_DROP_SUPER_TABLE_STMT, (SNode**)&pStmt);
|
||||
CHECK_MAKE_NODE(pStmt);
|
||||
strcpy(pStmt->dbName, ((SRealTableNode*)pRealTable)->table.dbName);
|
||||
strcpy(pStmt->tableName, ((SRealTableNode*)pRealTable)->table.tableName);
|
||||
tstrncpy(pStmt->dbName, ((SRealTableNode*)pRealTable)->table.dbName, TSDB_DB_NAME_LEN);
|
||||
tstrncpy(pStmt->tableName, ((SRealTableNode*)pRealTable)->table.tableName, TSDB_TABLE_NAME_LEN);
|
||||
pStmt->ignoreNotExists = ignoreNotExists;
|
||||
pStmt->withOpt = withOpt;
|
||||
nodesDestroyNode(pRealTable);
|
||||
|
|
@ -2460,8 +2460,8 @@ _err:
|
|||
}
|
||||
|
||||
static SNode* createAlterTableStmtFinalize(SNode* pRealTable, SAlterTableStmt* pStmt) {
|
||||
strcpy(pStmt->dbName, ((SRealTableNode*)pRealTable)->table.dbName);
|
||||
strcpy(pStmt->tableName, ((SRealTableNode*)pRealTable)->table.tableName);
|
||||
tstrncpy(pStmt->dbName, ((SRealTableNode*)pRealTable)->table.dbName, TSDB_DB_NAME_LEN);
|
||||
tstrncpy(pStmt->tableName, ((SRealTableNode*)pRealTable)->table.tableName, TSDB_TABLE_NAME_LEN);
|
||||
nodesDestroyNode(pRealTable);
|
||||
return (SNode*)pStmt;
|
||||
}
|
||||
|
|
@ -2780,8 +2780,8 @@ SNode* createShowCreateTableStmt(SAstCreateContext* pCxt, ENodeType type, SNode*
|
|||
SShowCreateTableStmt* pStmt = NULL;
|
||||
pCxt->errCode = nodesMakeNode(type, (SNode**)&pStmt);
|
||||
CHECK_MAKE_NODE(pStmt);
|
||||
strcpy(pStmt->dbName, ((SRealTableNode*)pRealTable)->table.dbName);
|
||||
strcpy(pStmt->tableName, ((SRealTableNode*)pRealTable)->table.tableName);
|
||||
tstrncpy(pStmt->dbName, ((SRealTableNode*)pRealTable)->table.dbName, TSDB_DB_NAME_LEN);
|
||||
tstrncpy(pStmt->tableName, ((SRealTableNode*)pRealTable)->table.tableName, TSDB_TABLE_NAME_LEN);
|
||||
nodesDestroyNode(pRealTable);
|
||||
return (SNode*)pStmt;
|
||||
_err:
|
||||
|
|
@ -2794,8 +2794,8 @@ SNode* createShowCreateViewStmt(SAstCreateContext* pCxt, ENodeType type, SNode*
|
|||
SShowCreateViewStmt* pStmt = NULL;
|
||||
pCxt->errCode = nodesMakeNode(type, (SNode**)&pStmt);
|
||||
CHECK_MAKE_NODE(pStmt);
|
||||
strcpy(pStmt->dbName, ((SRealTableNode*)pRealTable)->table.dbName);
|
||||
strcpy(pStmt->viewName, ((SRealTableNode*)pRealTable)->table.tableName);
|
||||
tstrncpy(pStmt->dbName, ((SRealTableNode*)pRealTable)->table.dbName, TSDB_DB_NAME_LEN);
|
||||
tstrncpy(pStmt->viewName, ((SRealTableNode*)pRealTable)->table.tableName, TSDB_TABLE_NAME_LEN);
|
||||
nodesDestroyNode(pRealTable);
|
||||
return (SNode*)pStmt;
|
||||
_err:
|
||||
|
|
@ -2808,8 +2808,8 @@ SNode* createShowTableDistributedStmt(SAstCreateContext* pCxt, SNode* pRealTable
|
|||
SShowTableDistributedStmt* pStmt = NULL;
|
||||
pCxt->errCode = nodesMakeNode(QUERY_NODE_SHOW_TABLE_DISTRIBUTED_STMT, (SNode**)&pStmt);
|
||||
CHECK_MAKE_NODE(pStmt);
|
||||
strcpy(pStmt->dbName, ((SRealTableNode*)pRealTable)->table.dbName);
|
||||
strcpy(pStmt->tableName, ((SRealTableNode*)pRealTable)->table.tableName);
|
||||
tstrncpy(pStmt->dbName, ((SRealTableNode*)pRealTable)->table.dbName, TSDB_DB_NAME_LEN);
|
||||
tstrncpy(pStmt->tableName, ((SRealTableNode*)pRealTable)->table.tableName, TSDB_TABLE_NAME_LEN);
|
||||
nodesDestroyNode(pRealTable);
|
||||
return (SNode*)pStmt;
|
||||
_err:
|
||||
|
|
@ -2965,7 +2965,7 @@ SNode* createCreateUserStmt(SAstCreateContext* pCxt, SToken* pUserName, const ST
|
|||
pCxt->errCode = nodesMakeNode(QUERY_NODE_CREATE_USER_STMT, (SNode**)&pStmt);
|
||||
CHECK_MAKE_NODE(pStmt);
|
||||
COPY_STRING_FORM_ID_TOKEN(pStmt->userName, pUserName);
|
||||
strcpy(pStmt->password, password);
|
||||
tstrncpy(pStmt->password, password, TSDB_USET_PASSWORD_LEN);
|
||||
pStmt->sysinfo = sysinfo;
|
||||
pStmt->createDb = createDb;
|
||||
pStmt->isImport = is_import;
|
||||
|
|
@ -2987,7 +2987,7 @@ SNode* createAlterUserStmt(SAstCreateContext* pCxt, SToken* pUserName, int8_t al
|
|||
char password[TSDB_USET_PASSWORD_LEN] = {0};
|
||||
SToken* pVal = pAlterInfo;
|
||||
CHECK_NAME(checkPassword(pCxt, pVal, password));
|
||||
strcpy(pStmt->password, password);
|
||||
tstrncpy(pStmt->password, password, TSDB_USET_PASSWORD_LEN);
|
||||
break;
|
||||
}
|
||||
case TSDB_ALTER_USER_ENABLE: {
|
||||
|
|
@ -3297,8 +3297,8 @@ SNode* createCreateTopicStmtUseTable(SAstCreateContext* pCxt, bool ignoreExists,
|
|||
pStmt->withMeta = withMeta;
|
||||
pStmt->pWhere = pWhere;
|
||||
|
||||
strcpy(pStmt->subDbName, ((SRealTableNode*)pRealTable)->table.dbName);
|
||||
strcpy(pStmt->subSTbName, ((SRealTableNode*)pRealTable)->table.tableName);
|
||||
tstrncpy(pStmt->subDbName, ((SRealTableNode*)pRealTable)->table.dbName, TSDB_DB_NAME_LEN);
|
||||
tstrncpy(pStmt->subSTbName, ((SRealTableNode*)pRealTable)->table.tableName, TSDB_TABLE_NAME_LEN);
|
||||
nodesDestroyNode(pRealTable);
|
||||
return (SNode*)pStmt;
|
||||
_err:
|
||||
|
|
@ -3411,8 +3411,8 @@ SNode* createDescribeStmt(SAstCreateContext* pCxt, SNode* pRealTable) {
|
|||
SDescribeStmt* pStmt = NULL;
|
||||
pCxt->errCode = nodesMakeNode(QUERY_NODE_DESCRIBE_STMT, (SNode**)&pStmt);
|
||||
CHECK_MAKE_NODE(pStmt);
|
||||
strcpy(pStmt->dbName, ((SRealTableNode*)pRealTable)->table.dbName);
|
||||
strcpy(pStmt->tableName, ((SRealTableNode*)pRealTable)->table.tableName);
|
||||
tstrncpy(pStmt->dbName, ((SRealTableNode*)pRealTable)->table.dbName, TSDB_DB_NAME_LEN);
|
||||
tstrncpy(pStmt->tableName, ((SRealTableNode*)pRealTable)->table.tableName, TSDB_TABLE_NAME_LEN);
|
||||
nodesDestroyNode(pRealTable);
|
||||
return (SNode*)pStmt;
|
||||
_err:
|
||||
|
|
@ -3492,8 +3492,8 @@ SNode* createCreateViewStmt(SAstCreateContext* pCxt, bool orReplace, SNode* pVie
|
|||
}
|
||||
pStmt->pQuerySql = tstrdup(pAs->z + i);
|
||||
CHECK_OUT_OF_MEM(pStmt->pQuerySql);
|
||||
strcpy(pStmt->dbName, ((SViewNode*)pView)->table.dbName);
|
||||
strcpy(pStmt->viewName, ((SViewNode*)pView)->table.tableName);
|
||||
tstrncpy(pStmt->dbName, ((SViewNode*)pView)->table.dbName, TSDB_DB_NAME_LEN);
|
||||
tstrncpy(pStmt->viewName, ((SViewNode*)pView)->table.tableName, TSDB_VIEW_NAME_LEN);
|
||||
nodesDestroyNode(pView);
|
||||
pStmt->orReplace = orReplace;
|
||||
pStmt->pQuery = pQuery;
|
||||
|
|
@ -3511,8 +3511,8 @@ SNode* createDropViewStmt(SAstCreateContext* pCxt, bool ignoreNotExists, SNode*
|
|||
pCxt->errCode = nodesMakeNode(QUERY_NODE_DROP_VIEW_STMT, (SNode**)&pStmt);
|
||||
CHECK_MAKE_NODE(pStmt);
|
||||
pStmt->ignoreNotExists = ignoreNotExists;
|
||||
strcpy(pStmt->dbName, ((SViewNode*)pView)->table.dbName);
|
||||
strcpy(pStmt->viewName, ((SViewNode*)pView)->table.tableName);
|
||||
tstrncpy(pStmt->dbName, ((SViewNode*)pView)->table.dbName, TSDB_DB_NAME_LEN);
|
||||
tstrncpy(pStmt->viewName, ((SViewNode*)pView)->table.tableName, TSDB_VIEW_NAME_LEN);
|
||||
nodesDestroyNode(pView);
|
||||
return (SNode*)pStmt;
|
||||
_err:
|
||||
|
|
@ -3597,8 +3597,8 @@ SNode* createCreateStreamStmt(SAstCreateContext* pCxt, bool ignoreExists, SToken
|
|||
pCxt->errCode = nodesMakeNode(QUERY_NODE_CREATE_STREAM_STMT, (SNode**)&pStmt);
|
||||
CHECK_MAKE_NODE(pStmt);
|
||||
COPY_STRING_FORM_ID_TOKEN(pStmt->streamName, pStreamName);
|
||||
strcpy(pStmt->targetDbName, ((SRealTableNode*)pRealTable)->table.dbName);
|
||||
strcpy(pStmt->targetTabName, ((SRealTableNode*)pRealTable)->table.tableName);
|
||||
tstrncpy(pStmt->targetDbName, ((SRealTableNode*)pRealTable)->table.dbName, TSDB_DB_NAME_LEN);
|
||||
tstrncpy(pStmt->targetTabName, ((SRealTableNode*)pRealTable)->table.tableName, TSDB_TABLE_NAME_LEN);
|
||||
nodesDestroyNode(pRealTable);
|
||||
pStmt->ignoreExists = ignoreExists;
|
||||
pStmt->pOptions = (SStreamOptions*)pOptions;
|
||||
|
|
@ -3852,9 +3852,9 @@ SNode* createInsertStmt(SAstCreateContext* pCxt, SNode* pTable, SNodeList* pCols
|
|||
pStmt->pCols = pCols;
|
||||
pStmt->pQuery = pQuery;
|
||||
if (QUERY_NODE_SELECT_STMT == nodeType(pQuery)) {
|
||||
strcpy(((SSelectStmt*)pQuery)->stmtName, ((STableNode*)pTable)->tableAlias);
|
||||
tstrncpy(((SSelectStmt*)pQuery)->stmtName, ((STableNode*)pTable)->tableAlias, TSDB_TABLE_NAME_LEN);
|
||||
} else if (QUERY_NODE_SET_OPERATOR == nodeType(pQuery)) {
|
||||
strcpy(((SSetOperator*)pQuery)->stmtName, ((STableNode*)pTable)->tableAlias);
|
||||
tstrncpy(((SSetOperator*)pQuery)->stmtName, ((STableNode*)pTable)->tableAlias, TSDB_TABLE_NAME_LEN);
|
||||
}
|
||||
return (SNode*)pStmt;
|
||||
_err:
|
||||
|
|
|
|||
|
|
@ -480,8 +480,8 @@ static int32_t collectMetaKeyFromExplain(SCollectMetaKeyCxt* pCxt, SExplainStmt*
|
|||
|
||||
static int32_t collectMetaKeyFromDescribe(SCollectMetaKeyCxt* pCxt, SDescribeStmt* pStmt) {
|
||||
SName name = {.type = TSDB_TABLE_NAME_T, .acctId = pCxt->pParseCxt->acctId};
|
||||
strcpy(name.dbname, pStmt->dbName);
|
||||
strcpy(name.tname, pStmt->tableName);
|
||||
tstrncpy(name.dbname, pStmt->dbName, TSDB_DB_NAME_LEN);
|
||||
tstrncpy(name.tname, pStmt->tableName, TSDB_TABLE_NAME_LEN);
|
||||
int32_t code = catalogRemoveTableMeta(pCxt->pParseCxt->pCatalog, &name);
|
||||
#ifdef TD_ENTERPRISE
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
|
|
@ -781,8 +781,8 @@ static int32_t collectMetaKeyFromShowCreateDatabase(SCollectMetaKeyCxt* pCxt, SS
|
|||
|
||||
static int32_t collectMetaKeyFromShowCreateTable(SCollectMetaKeyCxt* pCxt, SShowCreateTableStmt* pStmt) {
|
||||
SName name = {.type = TSDB_TABLE_NAME_T, .acctId = pCxt->pParseCxt->acctId};
|
||||
strcpy(name.dbname, pStmt->dbName);
|
||||
strcpy(name.tname, pStmt->tableName);
|
||||
tstrncpy(name.dbname, pStmt->dbName, TSDB_DB_NAME_LEN);
|
||||
tstrncpy(name.tname, pStmt->tableName, TSDB_TABLE_NAME_LEN);
|
||||
int32_t code = catalogRemoveTableMeta(pCxt->pParseCxt->pCatalog, &name);
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
code = reserveTableCfgInCache(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, pCxt->pMetaCache);
|
||||
|
|
@ -799,8 +799,8 @@ static int32_t collectMetaKeyFromShowCreateTable(SCollectMetaKeyCxt* pCxt, SShow
|
|||
|
||||
static int32_t collectMetaKeyFromShowCreateView(SCollectMetaKeyCxt* pCxt, SShowCreateViewStmt* pStmt) {
|
||||
SName name = {.type = TSDB_TABLE_NAME_T, .acctId = pCxt->pParseCxt->acctId};
|
||||
strcpy(name.dbname, pStmt->dbName);
|
||||
strcpy(name.tname, pStmt->viewName);
|
||||
tstrncpy(name.dbname, pStmt->dbName, TSDB_DB_NAME_LEN);
|
||||
tstrncpy(name.tname, pStmt->viewName, TSDB_TABLE_NAME_LEN);
|
||||
char dbFName[TSDB_DB_FNAME_LEN];
|
||||
(void)tNameGetFullDbName(&name, dbFName);
|
||||
int32_t code = catalogRemoveViewMeta(pCxt->pParseCxt->pCatalog, dbFName, 0, pStmt->viewName, 0);
|
||||
|
|
@ -841,8 +841,8 @@ static int32_t collectMetaKeyFromInsert(SCollectMetaKeyCxt* pCxt, SInsertStmt* p
|
|||
|
||||
static int32_t collectMetaKeyFromShowBlockDist(SCollectMetaKeyCxt* pCxt, SShowTableDistributedStmt* pStmt) {
|
||||
SName name = {.type = TSDB_TABLE_NAME_T, .acctId = pCxt->pParseCxt->acctId};
|
||||
strcpy(name.dbname, pStmt->dbName);
|
||||
strcpy(name.tname, pStmt->tableName);
|
||||
tstrncpy(name.dbname, pStmt->dbName, TSDB_DB_NAME_LEN);
|
||||
tstrncpy(name.tname, pStmt->tableName, TSDB_TABLE_NAME_LEN);
|
||||
int32_t code = catalogRemoveTableMeta(pCxt->pParseCxt->pCatalog, &name);
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
code = collectMetaKeyFromRealTableImpl(pCxt, pStmt->dbName, pStmt->tableName, AUTH_TYPE_READ);
|
||||
|
|
|
|||
|
|
@ -134,8 +134,8 @@ EDealRes rewriteAuthTable(SNode* pNode, void* pContext) {
|
|||
if (QUERY_NODE_COLUMN == nodeType(pNode)) {
|
||||
SColumnNode* pCol = (SColumnNode*)pNode;
|
||||
SAuthRewriteCxt* pCxt = (SAuthRewriteCxt*)pContext;
|
||||
strcpy(pCol->tableName, pCxt->pTarget->tableName);
|
||||
strcpy(pCol->tableAlias, pCxt->pTarget->tableAlias);
|
||||
tstrncpy(pCol->tableName, pCxt->pTarget->tableName, TSDB_TABLE_NAME_LEN);
|
||||
tstrncpy(pCol->tableAlias, pCxt->pTarget->tableAlias, TSDB_TABLE_NAME_LEN);
|
||||
}
|
||||
|
||||
return DEAL_RES_CONTINUE;
|
||||
|
|
|
|||
|
|
@ -178,14 +178,14 @@ static EDealRes doFindAndReplaceNode(SNode** pNode, void* pContext) {
|
|||
SCalcConstContext* pCxt = pContext;
|
||||
if (pCxt->replaceCxt.pTarget == *pNode) {
|
||||
char aliasName[TSDB_COL_NAME_LEN] = {0};
|
||||
strcpy(aliasName, ((SExprNode*)*pNode)->aliasName);
|
||||
tstrncpy(aliasName, ((SExprNode*)*pNode)->aliasName, TSDB_COL_NAME_LEN);
|
||||
nodesDestroyNode(*pNode);
|
||||
*pNode = NULL;
|
||||
pCxt->code = nodesCloneNode(pCxt->replaceCxt.pNew, pNode);
|
||||
if (NULL == *pNode) {
|
||||
return DEAL_RES_ERROR;
|
||||
}
|
||||
strcpy(((SExprNode*)*pNode)->aliasName, aliasName);
|
||||
tstrncpy(((SExprNode*)*pNode)->aliasName, aliasName, TSDB_COL_NAME_LEN);
|
||||
|
||||
pCxt->replaceCxt.replaced = true;
|
||||
return DEAL_RES_END;
|
||||
|
|
@ -228,14 +228,14 @@ static int32_t calcConstProject(SCalcConstContext* pCxt, SNode* pProject, bool d
|
|||
SAssociationNode* pAssNode = taosArrayGet(pAssociation, i);
|
||||
SNode** pCol = pAssNode->pPlace;
|
||||
if (*pCol == pAssNode->pAssociationNode) {
|
||||
strcpy(aliasName, ((SExprNode*)*pCol)->aliasName);
|
||||
tstrncpy(aliasName, ((SExprNode*)*pCol)->aliasName, TSDB_COL_NAME_LEN);
|
||||
SArray* pOrigAss = NULL;
|
||||
TSWAP(((SExprNode*)*pCol)->pAssociation, pOrigAss);
|
||||
nodesDestroyNode(*pCol);
|
||||
*pCol = NULL;
|
||||
code = nodesCloneNode(*pNew, pCol);
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
strcpy(((SExprNode*)*pCol)->aliasName, aliasName);
|
||||
tstrncpy(((SExprNode*)*pCol)->aliasName, aliasName, TSDB_COL_NAME_LEN);
|
||||
TSWAP(pOrigAss, ((SExprNode*)*pCol)->pAssociation);
|
||||
}
|
||||
taosArrayDestroy(pOrigAss);
|
||||
|
|
|
|||
|
|
@ -927,7 +927,7 @@ int32_t buildBoundFields(int32_t numOfBound, int16_t* boundColumns, SSchema* pSc
|
|||
|
||||
for (int32_t i = 0; i < numOfBound; ++i) {
|
||||
schema = &pSchema[boundColumns[i]];
|
||||
strcpy((*fields)[i].name, schema->name);
|
||||
tstrncpy((*fields)[i].name, schema->name, 65);
|
||||
(*fields)[i].type = schema->type;
|
||||
(*fields)[i].bytes = schema->bytes;
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -250,7 +250,7 @@ int32_t generateSyntaxErrMsgExt(SMsgBuf* pBuf, int32_t errCode, const char* pFor
|
|||
|
||||
int32_t buildInvalidOperationMsg(SMsgBuf* pBuf, const char* msg) {
|
||||
if (pBuf->buf) {
|
||||
strncpy(pBuf->buf, msg, pBuf->len);
|
||||
tstrncpy(pBuf->buf, msg, pBuf->len);
|
||||
}
|
||||
|
||||
return TSDB_CODE_TSC_INVALID_OPERATION;
|
||||
|
|
@ -277,7 +277,7 @@ int32_t buildSyntaxErrMsg(SMsgBuf* pBuf, const char* additionalInfo, const char*
|
|||
}
|
||||
|
||||
char buf[64] = {0}; // only extract part of sql string
|
||||
strncpy(buf, sourceStr, tListLen(buf) - 1);
|
||||
tstrncpy(buf, sourceStr, tListLen(buf));
|
||||
|
||||
if (additionalInfo != NULL) {
|
||||
snprintf(pBuf->buf, pBuf->len, msgFormat2, buf, additionalInfo);
|
||||
|
|
@ -454,7 +454,7 @@ int32_t parseJsontoTagData(const char* json, SArray* pTagVals, STag** ppTag, voi
|
|||
continue;
|
||||
}
|
||||
STagVal val = {0};
|
||||
// strcpy(val.colName, colName);
|
||||
// TSDB_DB_FNAME_LENme, colName);
|
||||
val.pKey = jsonKey;
|
||||
retCode = taosHashPut(keyHash, jsonKey, keyLen, &keyLen,
|
||||
CHAR_BYTES); // add key to hash to remove dumplicate, value is useless
|
||||
|
|
@ -596,15 +596,15 @@ int32_t getVnodeSysTableTargetName(int32_t acctId, SNode* pWhere, SName* pName)
|
|||
|
||||
static int32_t userAuthToString(int32_t acctId, const char* pUser, const char* pDb, const char* pTable, AUTH_TYPE type,
|
||||
char* pStr, bool isView) {
|
||||
return sprintf(pStr, "%s*%d*%s*%s*%d*%d", pUser, acctId, pDb, (NULL == pTable || '\0' == pTable[0]) ? "``" : pTable,
|
||||
type, isView);
|
||||
return snprintf(pStr, USER_AUTH_KEY_MAX_LEN, "%s*%d*%s*%s*%d*%d", pUser, acctId, pDb,
|
||||
(NULL == pTable || '\0' == pTable[0]) ? "``" : pTable, type, isView);
|
||||
}
|
||||
|
||||
static int32_t getIntegerFromAuthStr(const char* pStart, char** pNext) {
|
||||
char* p = strchr(pStart, '*');
|
||||
char buf[10] = {0};
|
||||
if (NULL == p) {
|
||||
strcpy(buf, pStart);
|
||||
tstrncpy(buf, pStart, 10);
|
||||
*pNext = NULL;
|
||||
} else {
|
||||
strncpy(buf, pStart, p - pStart);
|
||||
|
|
@ -616,7 +616,7 @@ static int32_t getIntegerFromAuthStr(const char* pStart, char** pNext) {
|
|||
static void getStringFromAuthStr(const char* pStart, char* pStr, char** pNext) {
|
||||
char* p = strchr(pStart, '*');
|
||||
if (NULL == p) {
|
||||
strcpy(pStr, pStart);
|
||||
tstrncpy(pStr, pStart, strlen(pStart) + 1);
|
||||
*pNext = NULL;
|
||||
} else {
|
||||
strncpy(pStr, pStart, p - pStart);
|
||||
|
|
@ -708,7 +708,7 @@ static int32_t buildTableReqFromDb(SHashObj* pDbsHash, SArray** pDbs) {
|
|||
SParseTablesMetaReq* p = taosHashIterate(pDbsHash, NULL);
|
||||
while (NULL != p) {
|
||||
STablesReq req = {0};
|
||||
strcpy(req.dbFName, p->dbFName);
|
||||
tstrncpy(req.dbFName, p->dbFName, TSDB_DB_FNAME_LEN);
|
||||
int32_t code = buildTableReq(p->pTables, &req.pTables);
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
if (NULL == taosArrayPush(*pDbs, &req)) {
|
||||
|
|
@ -832,7 +832,7 @@ int32_t createSelectStmtImpl(bool isDistinct, SNodeList* pProjectionList, SNode*
|
|||
select->isDistinct = isDistinct;
|
||||
select->pProjectionList = pProjectionList;
|
||||
select->pFromTable = pTable;
|
||||
sprintf(select->stmtName, "%p", select);
|
||||
snprintf(select->stmtName, TSDB_TABLE_NAME_LEN, "%p", select);
|
||||
select->timeLineResMode = select->isDistinct ? TIME_LINE_NONE : TIME_LINE_GLOBAL;
|
||||
select->timeLineCurMode = TIME_LINE_GLOBAL;
|
||||
select->onlyHasKeepOrderFunc = true;
|
||||
|
|
|
|||
|
|
@ -221,7 +221,7 @@ static int32_t setValueByBindParam(SValueNode* pVal, TAOS_MULTI_BIND* pParam, vo
|
|||
|
||||
static EDealRes rewriteQueryExprAliasImpl(SNode* pNode, void* pContext) {
|
||||
if (nodesIsExprNode(pNode) && QUERY_NODE_COLUMN != nodeType(pNode)) {
|
||||
sprintf(((SExprNode*)pNode)->aliasName, "#%d", *(int32_t*)pContext);
|
||||
snprintf(((SExprNode*)pNode)->aliasName, TSDB_COL_NAME_LEN, "#%d", *(int32_t*)pContext);
|
||||
++(*(int32_t*)pContext);
|
||||
}
|
||||
return DEAL_RES_CONTINUE;
|
||||
|
|
@ -528,9 +528,6 @@ int32_t qStmtBindParams2(SQuery* pQuery, TAOS_STMT2_BIND* pParams, int32_t colId
|
|||
nodesDestroyNode(pQuery->pRoot);
|
||||
pQuery->pRoot = NULL;
|
||||
code = nodesCloneNode(pQuery->pPrepareRoot, &pQuery->pRoot);
|
||||
if (NULL == pQuery->pRoot) {
|
||||
code = code;
|
||||
}
|
||||
}
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
rewriteExprAlias(pQuery->pRoot);
|
||||
|
|
|
|||
|
|
@ -119,9 +119,9 @@ static EDealRes doRewriteExpr(SNode** pNode, void* pContext) {
|
|||
}
|
||||
SExprNode* pToBeRewrittenExpr = (SExprNode*)(*pNode);
|
||||
pCol->node.resType = pToBeRewrittenExpr->resType;
|
||||
strcpy(pCol->node.aliasName, pToBeRewrittenExpr->aliasName);
|
||||
strcpy(pCol->node.userAlias, ((SExprNode*)pExpr)->userAlias);
|
||||
strcpy(pCol->colName, ((SExprNode*)pExpr)->aliasName);
|
||||
tstrncpy(pCol->node.aliasName, pToBeRewrittenExpr->aliasName, TSDB_COL_NAME_LEN);
|
||||
tstrncpy(pCol->node.userAlias, ((SExprNode*)pExpr)->userAlias, TSDB_COL_NAME_LEN);
|
||||
tstrncpy(pCol->colName, ((SExprNode*)pExpr)->aliasName, TSDB_COL_NAME_LEN);
|
||||
pCol->node.projIdx = ((SExprNode*)(*pNode))->projIdx;
|
||||
if (QUERY_NODE_FUNCTION == nodeType(pExpr)) {
|
||||
setColumnInfo((SFunctionNode*)pExpr, pCol, pCxt->isPartitionBy);
|
||||
|
|
@ -150,7 +150,7 @@ static EDealRes doNameExpr(SNode* pNode, void* pContext) {
|
|||
case QUERY_NODE_LOGIC_CONDITION:
|
||||
case QUERY_NODE_FUNCTION: {
|
||||
if ('\0' == ((SExprNode*)pNode)->aliasName[0]) {
|
||||
sprintf(((SExprNode*)pNode)->aliasName, "#expr_%p", pNode);
|
||||
snprintf(((SExprNode*)pNode)->aliasName, TSDB_COL_NAME_LEN, "#expr_%p", pNode);
|
||||
}
|
||||
return DEAL_RES_IGNORE_CHILD;
|
||||
}
|
||||
|
|
@ -311,12 +311,12 @@ static SNode* createFirstCol(SRealTableNode* pTable, const SSchema* pSchema) {
|
|||
pCol->tableId = pTable->pMeta->uid;
|
||||
pCol->colId = pSchema->colId;
|
||||
pCol->colType = COLUMN_TYPE_COLUMN;
|
||||
strcpy(pCol->tableAlias, pTable->table.tableAlias);
|
||||
strcpy(pCol->tableName, pTable->table.tableName);
|
||||
tstrncpy(pCol->tableAlias, pTable->table.tableAlias, TSDB_TABLE_NAME_LEN);
|
||||
tstrncpy(pCol->tableName, pTable->table.tableName, TSDB_TABLE_NAME_LEN);
|
||||
pCol->isPk = pSchema->flags & COL_IS_KEY;
|
||||
pCol->tableHasPk = hasPkInTable(pTable->pMeta);
|
||||
pCol->numOfPKs = pTable->pMeta->tableInfo.numOfPKs;
|
||||
strcpy(pCol->colName, pSchema->name);
|
||||
tstrncpy(pCol->colName, pSchema->name, TSDB_COL_NAME_LEN);
|
||||
return (SNode*)pCol;
|
||||
}
|
||||
|
||||
|
|
@ -392,8 +392,8 @@ static int32_t makeScanLogicNode(SLogicPlanContext* pCxt, SRealTableNode* pRealT
|
|||
pScan->scanRange = TSWINDOW_INITIALIZER;
|
||||
pScan->tableName.type = TSDB_TABLE_NAME_T;
|
||||
pScan->tableName.acctId = pCxt->pPlanCxt->acctId;
|
||||
strcpy(pScan->tableName.dbname, pRealTable->table.dbName);
|
||||
strcpy(pScan->tableName.tname, pRealTable->table.tableName);
|
||||
tstrncpy(pScan->tableName.dbname, pRealTable->table.dbName, TSDB_DB_NAME_LEN);
|
||||
tstrncpy(pScan->tableName.tname, pRealTable->table.tableName, TSDB_TABLE_NAME_LEN);
|
||||
pScan->showRewrite = pCxt->pPlanCxt->showRewrite;
|
||||
pScan->ratio = pRealTable->ratio;
|
||||
pScan->dataRequired = FUNC_DATA_REQUIRED_DATA_LOAD;
|
||||
|
|
@ -785,12 +785,12 @@ static int32_t addWinJoinPrimKeyToAggFuncs(SSelectStmt* pSelect, SNodeList** pLi
|
|||
}
|
||||
|
||||
SSchema* pColSchema = &pProbeTable->pMeta->schema[0];
|
||||
strcpy(pCol->dbName, pProbeTable->table.dbName);
|
||||
strcpy(pCol->tableAlias, pProbeTable->table.tableAlias);
|
||||
strcpy(pCol->tableName, pProbeTable->table.tableName);
|
||||
strcpy(pCol->colName, pColSchema->name);
|
||||
strcpy(pCol->node.aliasName, pColSchema->name);
|
||||
strcpy(pCol->node.userAlias, pColSchema->name);
|
||||
tstrncpy(pCol->dbName, pProbeTable->table.dbName, TSDB_DB_NAME_LEN);
|
||||
tstrncpy(pCol->tableAlias, pProbeTable->table.tableAlias, TSDB_TABLE_NAME_LEN);
|
||||
tstrncpy(pCol->tableName, pProbeTable->table.tableName, TSDB_TABLE_NAME_LEN);
|
||||
tstrncpy(pCol->colName, pColSchema->name, TSDB_COL_NAME_LEN);
|
||||
tstrncpy(pCol->node.aliasName, pColSchema->name, TSDB_COL_NAME_LEN);
|
||||
tstrncpy(pCol->node.userAlias, pColSchema->name, TSDB_COL_NAME_LEN);
|
||||
pCol->tableId = pProbeTable->pMeta->uid;
|
||||
pCol->tableType = pProbeTable->pMeta->tableType;
|
||||
pCol->colId = pColSchema->colId;
|
||||
|
|
@ -1557,7 +1557,7 @@ static int32_t createSortLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect
|
|||
if (TSDB_CODE_SUCCESS == code) {
|
||||
pSort->pSortKeys = NULL;
|
||||
code = nodesCloneList(pSelect->pOrderByList, &pSort->pSortKeys);
|
||||
if (NULL != pSort->pSortKeys) {
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
SNode* pNode = NULL;
|
||||
SOrderByExprNode* firstSortKey = (SOrderByExprNode*)nodesListGetNode(pSort->pSortKeys, 0);
|
||||
if (isPrimaryKeySort(pSelect->pOrderByList)) pSort->node.outputTsOrder = firstSortKey->order;
|
||||
|
|
@ -1624,10 +1624,7 @@ static int32_t createProjectLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSel
|
|||
|
||||
pProject->pProjections = NULL;
|
||||
code = nodesCloneList(pSelect->pProjectionList, &pProject->pProjections);
|
||||
if (NULL == pProject->pProjections) {
|
||||
code = code;
|
||||
}
|
||||
strcpy(pProject->stmtName, pSelect->stmtName);
|
||||
tstrncpy(pProject->stmtName, pSelect->stmtName, TSDB_TABLE_NAME_LEN);
|
||||
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
code = createColumnByProjections(pCxt, pSelect->stmtName, pSelect->pProjectionList, &pProject->node.pTargets);
|
||||
|
|
@ -2117,7 +2114,7 @@ static int32_t createVnodeModifLogicNodeByDelete(SLogicPlanContext* pCxt, SDelet
|
|||
pModify->tableId = pRealTable->pMeta->uid;
|
||||
pModify->tableType = pRealTable->pMeta->tableType;
|
||||
snprintf(pModify->tableName, sizeof(pModify->tableName), "%s", pRealTable->table.tableName);
|
||||
strcpy(pModify->tsColName, pRealTable->pMeta->schema->name);
|
||||
tstrncpy(pModify->tsColName, pRealTable->pMeta->schema->name, TSDB_COL_NAME_LEN);
|
||||
pModify->deleteTimeRange = pDelete->timeRange;
|
||||
pModify->pAffectedRows = NULL;
|
||||
code = nodesCloneNode(pDelete->pCountFunc, &pModify->pAffectedRows);
|
||||
|
|
|
|||
|
|
@ -188,7 +188,7 @@ static EDealRes optRebuildTbanme(SNode** pNode, void* pContext) {
|
|||
*(int32_t*)pContext = code;
|
||||
return DEAL_RES_ERROR;
|
||||
}
|
||||
strcpy(pFunc->functionName, "tbname");
|
||||
tstrncpy(pFunc->functionName, "tbname", TSDB_FUNC_NAME_LEN);
|
||||
pFunc->funcType = FUNCTION_TYPE_TBNAME;
|
||||
pFunc->node.resType = ((SColumnNode*)*pNode)->node.resType;
|
||||
nodesDestroyNode(*pNode);
|
||||
|
|
@ -1302,9 +1302,7 @@ static int32_t pdcJoinAddPreFilterColsToTarget(SOptimizeContext* pCxt, SJoinLogi
|
|||
SNodeList* pCondCols = NULL;
|
||||
code = nodesMakeList(&pCondCols);
|
||||
SNodeList* pTargets = NULL;
|
||||
if (NULL == pCondCols) {
|
||||
code = code;
|
||||
} else {
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
code = nodesCollectColumnsFromNode(pJoin->pColOnCond, NULL, COLLECT_COL_TYPE_ALL, &pCondCols);
|
||||
}
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
|
|
@ -2959,9 +2957,9 @@ static int32_t smaIndexOptCreateSmaCol(SNode* pFunc, uint64_t tableId, int32_t c
|
|||
pCol->tableType = TSDB_SUPER_TABLE;
|
||||
pCol->colId = colId;
|
||||
pCol->colType = COLUMN_TYPE_COLUMN;
|
||||
strcpy(pCol->colName, ((SExprNode*)pFunc)->aliasName);
|
||||
tstrncpy(pCol->colName, ((SExprNode*)pFunc)->aliasName, TSDB_COL_NAME_LEN);
|
||||
pCol->node.resType = ((SExprNode*)pFunc)->resType;
|
||||
strcpy(pCol->node.aliasName, ((SExprNode*)pFunc)->aliasName);
|
||||
tstrncpy(pCol->node.aliasName, ((SExprNode*)pFunc)->aliasName, TSDB_COL_NAME_LEN);
|
||||
*ppNode = pCol;
|
||||
return code;
|
||||
}
|
||||
|
|
@ -3030,7 +3028,7 @@ static int32_t smaIndexOptCreateSmaCols(SNodeList* pFuncs, uint64_t tableId, SNo
|
|||
}
|
||||
SExprNode exprNode;
|
||||
exprNode.resType = ((SExprNode*)pWsNode)->resType;
|
||||
sprintf(exprNode.aliasName, "#expr_%d", index + 1);
|
||||
snprintf(exprNode.aliasName, TSDB_COL_NAME_LEN, "#expr_%d", index + 1);
|
||||
SColumnNode* pkNode = NULL;
|
||||
code = smaIndexOptCreateSmaCol((SNode*)&exprNode, tableId, PRIMARYKEY_TIMESTAMP_COL_ID, &pkNode);
|
||||
if (TSDB_CODE_SUCCESS != code) {
|
||||
|
|
@ -3200,7 +3198,7 @@ static void partTagsSetAlias(char* pAlias, const char* pTableAlias, const char*
|
|||
int32_t len = tsnprintf(name, TSDB_COL_FNAME_LEN, "%s.%s", pTableAlias, pColName);
|
||||
|
||||
(void)taosHashBinary(name, len);
|
||||
strncpy(pAlias, name, TSDB_COL_NAME_LEN - 1);
|
||||
tstrncpy(pAlias, name, TSDB_COL_NAME_LEN);
|
||||
}
|
||||
|
||||
static int32_t partTagsCreateWrapperFunc(const char* pFuncName, SNode* pNode, SFunctionNode** ppNode) {
|
||||
|
|
@ -3218,7 +3216,7 @@ static int32_t partTagsCreateWrapperFunc(const char* pFuncName, SNode* pNode, SF
|
|||
SColumnNode* pCol = (SColumnNode*)pNode;
|
||||
partTagsSetAlias(pFunc->node.aliasName, pCol->tableAlias, pCol->colName);
|
||||
} else {
|
||||
strcpy(pFunc->node.aliasName, ((SExprNode*)pNode)->aliasName);
|
||||
tstrncpy(pFunc->node.aliasName, ((SExprNode*)pNode)->aliasName, TSDB_COL_NAME_LEN);
|
||||
}
|
||||
code = nodesCloneNode(pNode, &pNew);
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
|
|
@ -3507,7 +3505,7 @@ static EDealRes eliminateProjOptRewriteScanTableAlias(SNode* pNode, void* pConte
|
|||
if (QUERY_NODE_COLUMN == nodeType(pNode)) {
|
||||
SColumnNode* pCol = (SColumnNode*)pNode;
|
||||
RewriteTableAliasCxt* pCtx = (RewriteTableAliasCxt*)pContext;
|
||||
strncpy(pCol->tableAlias, pCtx->newTableAlias, TSDB_TABLE_NAME_LEN);
|
||||
tstrncpy(pCol->tableAlias, pCtx->newTableAlias, TSDB_TABLE_NAME_LEN);
|
||||
}
|
||||
return DEAL_RES_CONTINUE;
|
||||
}
|
||||
|
|
@ -3761,7 +3759,7 @@ static int32_t rewriteTailOptCreateProjectExpr(SFunctionNode* pFunc, SNode** ppN
|
|||
if (NULL == pExpr) {
|
||||
return code;
|
||||
}
|
||||
strcpy(((SExprNode*)pExpr)->aliasName, pFunc->node.aliasName);
|
||||
tstrncpy(((SExprNode*)pExpr)->aliasName, pFunc->node.aliasName, TSDB_COL_NAME_LEN);
|
||||
*ppNode = pExpr;
|
||||
return code;
|
||||
}
|
||||
|
|
@ -3917,15 +3915,15 @@ static int32_t rewriteUniqueOptCreateFirstFunc(SFunctionNode* pSelectValue, SNod
|
|||
return code;
|
||||
}
|
||||
|
||||
strcpy(pFunc->functionName, "first");
|
||||
tstrncpy(pFunc->functionName, "first", TSDB_FUNC_NAME_LEN);
|
||||
if (NULL != pSelectValue) {
|
||||
strcpy(pFunc->node.aliasName, pSelectValue->node.aliasName);
|
||||
tstrncpy(pFunc->node.aliasName, pSelectValue->node.aliasName, TSDB_COL_NAME_LEN);
|
||||
} else {
|
||||
int64_t pointer = (int64_t)pFunc;
|
||||
char name[TSDB_FUNC_NAME_LEN + TSDB_POINTER_PRINT_BYTES + TSDB_NAME_DELIMITER_LEN + 1] = {0};
|
||||
int32_t len = tsnprintf(name, sizeof(name) - 1, "%s.%" PRId64 "", pFunc->functionName, pointer);
|
||||
(void)taosHashBinary(name, len);
|
||||
strncpy(pFunc->node.aliasName, name, TSDB_COL_NAME_LEN - 1);
|
||||
tstrncpy(pFunc->node.aliasName, name, TSDB_COL_NAME_LEN);
|
||||
}
|
||||
SNode* pNew = NULL;
|
||||
code = nodesCloneNode(pCol, &pNew);
|
||||
|
|
@ -4023,15 +4021,15 @@ static int32_t rewriteUniqueOptCreateProjectCol(SFunctionNode* pFunc, SNode** pp
|
|||
if (FUNCTION_TYPE_UNIQUE == pFunc->funcType) {
|
||||
SExprNode* pExpr = (SExprNode*)nodesListGetNode(pFunc->pParameterList, 0);
|
||||
if (QUERY_NODE_COLUMN == nodeType(pExpr)) {
|
||||
strcpy(pCol->tableAlias, ((SColumnNode*)pExpr)->tableAlias);
|
||||
strcpy(pCol->colName, ((SColumnNode*)pExpr)->colName);
|
||||
tstrncpy(pCol->tableAlias, ((SColumnNode*)pExpr)->tableAlias, TSDB_TABLE_NAME_LEN);
|
||||
tstrncpy(pCol->colName, ((SColumnNode*)pExpr)->colName, TSDB_COL_NAME_LEN);
|
||||
} else {
|
||||
strcpy(pCol->colName, pExpr->aliasName);
|
||||
tstrncpy(pCol->colName, pExpr->aliasName, TSDB_COL_NAME_LEN);
|
||||
}
|
||||
} else {
|
||||
strcpy(pCol->colName, pFunc->node.aliasName);
|
||||
tstrncpy(pCol->colName, pFunc->node.aliasName, TSDB_COL_NAME_LEN);
|
||||
}
|
||||
strcpy(pCol->node.aliasName, pFunc->node.aliasName);
|
||||
tstrncpy(pCol->node.aliasName, pFunc->node.aliasName, TSDB_COL_NAME_LEN);
|
||||
*ppNode = (SNode*)pCol;
|
||||
return code;
|
||||
}
|
||||
|
|
@ -4405,7 +4403,7 @@ static int32_t lastRowScanBuildFuncTypes(SScanLogicNode* pScan, SColumnNode* pCo
|
|||
return terrno;
|
||||
}
|
||||
pFuncTypeParam->pCol->colId = pColNode->colId;
|
||||
strcpy(pFuncTypeParam->pCol->name, pColNode->colName);
|
||||
tstrncpy(pFuncTypeParam->pCol->name, pColNode->colName, TSDB_COL_NAME_LEN);
|
||||
if (NULL == taosArrayPush(pScan->pFuncTypes, pFuncTypeParam)) {
|
||||
taosMemoryFree(pFuncTypeParam);
|
||||
return terrno;
|
||||
|
|
@ -4482,15 +4480,15 @@ static int32_t lastRowScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogic
|
|||
if (TSDB_CODE_SUCCESS != code) {
|
||||
break;
|
||||
}
|
||||
sprintf(((SColumnNode*)newColNode)->colName, "#dup_col.%p", newColNode);
|
||||
sprintf(((SColumnNode*)pParamNode)->colName, "#dup_col.%p", newColNode);
|
||||
snprintf(((SColumnNode*)newColNode)->colName, TSDB_COL_NAME_LEN, "#dup_col.%p", newColNode);
|
||||
snprintf(((SColumnNode*)pParamNode)->colName, TSDB_COL_NAME_LEN, "#dup_col.%p", newColNode);
|
||||
if (FUNCTION_TYPE_LAST_ROW == funcType &&
|
||||
((SColumnNode*)pParamNode)->colId == PRIMARYKEY_TIMESTAMP_COL_ID) {
|
||||
if (!adjLastRowTsColName) {
|
||||
adjLastRowTsColName = true;
|
||||
strncpy(tsColName, ((SColumnNode*)pParamNode)->colName, TSDB_COL_NAME_LEN);
|
||||
tstrncpy(tsColName, ((SColumnNode*)pParamNode)->colName, TSDB_COL_NAME_LEN);
|
||||
} else {
|
||||
strncpy(((SColumnNode*)pParamNode)->colName, tsColName, TSDB_COL_NAME_LEN);
|
||||
tstrncpy(((SColumnNode*)pParamNode)->colName, tsColName, TSDB_COL_NAME_LEN);
|
||||
nodesDestroyNode(newColNode);
|
||||
continue;
|
||||
}
|
||||
|
|
@ -4614,7 +4612,7 @@ static int32_t lastRowScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogic
|
|||
((cxt.pLastCols->length == 1 && nodesEqualNode((SNode*)pPKTsCol, nodesListGetNode(cxt.pLastCols, 0))) ||
|
||||
(pScan->node.pTargets->length == 2 && cxt.pkBytes > 0))) {
|
||||
// when select last(ts),tbname,ts from ..., we add another ts to targets
|
||||
sprintf(pPKTsCol->colName, "#sel_val.%p", pPKTsCol);
|
||||
snprintf(pPKTsCol->colName, TSDB_COL_NAME_LEN, "#sel_val.%p", pPKTsCol);
|
||||
SNode* pNew = NULL;
|
||||
code = nodesCloneNode((SNode*)pPKTsCol, &pNew);
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
|
|
@ -4631,7 +4629,7 @@ static int32_t lastRowScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogic
|
|||
if (pNonPKCol && cxt.pLastCols->length == 1 &&
|
||||
nodesEqualNode((SNode*)pNonPKCol, nodesListGetNode(cxt.pLastCols, 0))) {
|
||||
// when select last(c1), c1 from ..., we add c1 to targets
|
||||
sprintf(pNonPKCol->colName, "#sel_val.%p", pNonPKCol);
|
||||
snprintf(pNonPKCol->colName, TSDB_COL_NAME_LEN, "#sel_val.%p", pNonPKCol);
|
||||
SNode* pNew = NULL;
|
||||
code = nodesCloneNode((SNode*)pNonPKCol, &pNew);
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
|
|
@ -5403,10 +5401,10 @@ static bool tbCntScanOptIsEligibleLogicCond(STbCntScanOptInfo* pInfo, SLogicCond
|
|||
}
|
||||
if (!hasDbCond && 0 == strcmp(pCol->colName, "db_name")) {
|
||||
hasDbCond = true;
|
||||
strcpy(pInfo->table.dbname, pVal->literal);
|
||||
tstrncpy(pInfo->table.dbname, pVal->literal, TSDB_DB_NAME_LEN);
|
||||
} else if (!hasStbCond && 0 == strcmp(pCol->colName, "stable_name")) {
|
||||
hasStbCond = true;
|
||||
strcpy(pInfo->table.tname, pVal->literal);
|
||||
tstrncpy(pInfo->table.tname, pVal->literal, TSDB_TABLE_NAME_LEN);
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
|
|
@ -5470,8 +5468,8 @@ static int32_t tbCntScanOptCreateTableCountFunc(SNode** ppNode) {
|
|||
if (NULL == pFunc) {
|
||||
return code;
|
||||
}
|
||||
strcpy(pFunc->functionName, "_table_count");
|
||||
strcpy(pFunc->node.aliasName, "_table_count");
|
||||
tstrncpy(pFunc->functionName, "_table_count", TSDB_FUNC_NAME_LEN);
|
||||
tstrncpy(pFunc->node.aliasName, "_table_count", TSDB_COL_NAME_LEN);
|
||||
code = fmGetFuncInfo(pFunc, NULL, 0);
|
||||
if (TSDB_CODE_SUCCESS != code) {
|
||||
nodesDestroyNode((SNode*)pFunc);
|
||||
|
|
@ -5483,8 +5481,8 @@ static int32_t tbCntScanOptCreateTableCountFunc(SNode** ppNode) {
|
|||
|
||||
static int32_t tbCntScanOptRewriteScan(STbCntScanOptInfo* pInfo) {
|
||||
pInfo->pScan->scanType = SCAN_TYPE_TABLE_COUNT;
|
||||
strcpy(pInfo->pScan->tableName.dbname, pInfo->table.dbname);
|
||||
strcpy(pInfo->pScan->tableName.tname, pInfo->table.tname);
|
||||
tstrncpy(pInfo->pScan->tableName.dbname, pInfo->table.dbname, TSDB_DB_NAME_LEN);
|
||||
tstrncpy(pInfo->pScan->tableName.tname, pInfo->table.tname, TSDB_TABLE_NAME_LEN);
|
||||
NODES_DESTORY_LIST(pInfo->pScan->node.pTargets);
|
||||
NODES_DESTORY_LIST(pInfo->pScan->pScanCols);
|
||||
NODES_DESTORY_NODE(pInfo->pScan->node.pConditions);
|
||||
|
|
@ -5534,8 +5532,8 @@ static int32_t tbCntScanOptCreateSumFunc(SFunctionNode* pCntFunc, SNode* pParam,
|
|||
if (NULL == pFunc) {
|
||||
return code;
|
||||
}
|
||||
strcpy(pFunc->functionName, "sum");
|
||||
strcpy(pFunc->node.aliasName, pCntFunc->node.aliasName);
|
||||
tstrncpy(pFunc->functionName, "sum", TSDB_FUNC_NAME_LEN);
|
||||
tstrncpy(pFunc->node.aliasName, pCntFunc->node.aliasName, TSDB_COL_NAME_LEN);
|
||||
code = createColumnByRewriteExpr(pParam, &pFunc->pParameterList);
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
code = fmGetFuncInfo(pFunc, NULL, 0);
|
||||
|
|
@ -6312,29 +6310,22 @@ static int32_t stbJoinOptCreateDynQueryCtrlNode(SLogicNode* pRoot, SLogicNode* p
|
|||
if (TSDB_CODE_SUCCESS == code) {
|
||||
pDynCtrl->node.pChildren = NULL;
|
||||
code = nodesMakeList(&pDynCtrl->node.pChildren);
|
||||
if (NULL == pDynCtrl->node.pChildren) {
|
||||
code = code;
|
||||
}
|
||||
}
|
||||
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
pDynCtrl->stbJoin.pVgList = NULL;
|
||||
code = nodesMakeList(&pDynCtrl->stbJoin.pVgList);
|
||||
if (NULL == pDynCtrl->stbJoin.pVgList) {
|
||||
code = code;
|
||||
}
|
||||
}
|
||||
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
pDynCtrl->stbJoin.pUidList = NULL;
|
||||
code = nodesMakeList(&pDynCtrl->stbJoin.pUidList);
|
||||
if (NULL == pDynCtrl->stbJoin.pUidList) {
|
||||
code = code;
|
||||
}
|
||||
}
|
||||
|
||||
SJoinLogicNode* pHJoin = (SJoinLogicNode*)pPrev;
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
code = nodesListStrictAppend(pDynCtrl->stbJoin.pUidList, nodesListGetNode(pHJoin->node.pTargets, 0));
|
||||
}
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
code = nodesListStrictAppend(pDynCtrl->stbJoin.pUidList, nodesListGetNode(pHJoin->node.pTargets, 2));
|
||||
}
|
||||
|
|
@ -6353,9 +6344,6 @@ static int32_t stbJoinOptCreateDynQueryCtrlNode(SLogicNode* pRoot, SLogicNode* p
|
|||
if (TSDB_CODE_SUCCESS == code) {
|
||||
pDynCtrl->node.pTargets = NULL;
|
||||
code = nodesCloneList(pPost->pTargets, &pDynCtrl->node.pTargets);
|
||||
if (!pDynCtrl->node.pTargets) {
|
||||
code = code;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -7117,10 +7105,9 @@ int32_t tsmaOptCreateTsmaScanCols(const STSMAOptUsefulTsma* pTsma, const SNodeLi
|
|||
pCol->tableType = TSDB_SUPER_TABLE;
|
||||
pCol->tableId = pTsma->targetTbUid;
|
||||
pCol->colType = COLUMN_TYPE_COLUMN;
|
||||
strcpy(pCol->tableName, pTsma->targetTbName);
|
||||
strcpy(pCol->dbName, pTsma->pTsma->targetDbFName);
|
||||
strcpy(pCol->colName, pFunc->node.aliasName);
|
||||
strcpy(pCol->node.aliasName, pFunc->node.aliasName);
|
||||
tstrncpy(pCol->tableName, pTsma->targetTbName, TSDB_TABLE_NAME_LEN);
|
||||
tstrncpy(pCol->colName, pFunc->node.aliasName, TSDB_COL_NAME_LEN);
|
||||
tstrncpy(pCol->node.aliasName, pFunc->node.aliasName, TSDB_COL_NAME_LEN);
|
||||
pCol->node.resType.type = TSDB_DATA_TYPE_BINARY;
|
||||
code = nodesListMakeStrictAppend(&pScanCols, (SNode*)pCol);
|
||||
}
|
||||
|
|
@ -7144,8 +7131,8 @@ static int32_t tsmaOptRewriteTag(const STSMAOptCtx* pTsmaOptCtx, const STSMAOptU
|
|||
for (int32_t i = 0; i < pTsma->pTsma->pTags->size; ++i) {
|
||||
const SSchema* pSchema = taosArrayGet(pTsma->pTsma->pTags, i);
|
||||
if (strcmp(pTagCol->colName, pSchema->name) == 0) {
|
||||
strcpy(pTagCol->tableName, pTsma->targetTbName);
|
||||
strcpy(pTagCol->tableAlias, pTsma->targetTbName);
|
||||
tstrncpy(pTagCol->tableName, pTsma->targetTbName, TSDB_TABLE_NAME_LEN);
|
||||
tstrncpy(pTagCol->tableAlias, pTsma->targetTbName, TSDB_TABLE_NAME_LEN);
|
||||
pTagCol->tableId = pTsma->targetTbUid;
|
||||
pTagCol->tableType = TSDB_SUPER_TABLE;
|
||||
pTagCol->colId = pSchema->colId;
|
||||
|
|
@ -7170,8 +7157,8 @@ static int32_t tsmaOptRewriteTbname(const STSMAOptCtx* pTsmaOptCtx, SNode** pTbN
|
|||
nodesDestroyNode(*pTbNameNode);
|
||||
SColumnNode* pCol = (SColumnNode*)pRewrittenFunc;
|
||||
const SSchema* pSchema = taosArrayGet(pTsma->pTsma->pTags, pTsma->pTsma->pTags->size - 1);
|
||||
strcpy(pCol->tableName, pTsma->targetTbName);
|
||||
strcpy(pCol->tableAlias, pTsma->targetTbName);
|
||||
tstrncpy(pCol->tableName, pTsma->targetTbName, TSDB_TABLE_NAME_LEN);
|
||||
tstrncpy(pCol->tableAlias, pTsma->targetTbName, TSDB_TABLE_NAME_LEN);
|
||||
pCol->tableId = pTsma->targetTbUid;
|
||||
pCol->tableType = TSDB_SUPER_TABLE;
|
||||
pCol->colId = pSchema->colId;
|
||||
|
|
@ -7296,7 +7283,7 @@ static int32_t tsmaOptRewriteScan(STSMAOptCtx* pTsmaOptCtx, SScanLogicNode* pNew
|
|||
if (code == TSDB_CODE_SUCCESS) {
|
||||
pNewScan->stableId = pTsma->pTsma->destTbUid;
|
||||
pNewScan->tableId = pTsma->targetTbUid;
|
||||
strcpy(pNewScan->tableName.tname, pTsma->targetTbName);
|
||||
tstrncpy(pNewScan->tableName.tname, pTsma->targetTbName, TSDB_TABLE_NAME_LEN);
|
||||
}
|
||||
if (code == TSDB_CODE_SUCCESS) {
|
||||
code = tsmaOptRewriteNodeList(pNewScan->pScanPseudoCols, pTsmaOptCtx, pTsma, true, true);
|
||||
|
|
@ -7349,12 +7336,12 @@ static int32_t tsmaOptCreateWStart(int8_t precision, SFunctionNode** pWStartOut)
|
|||
if (NULL == pWStart) {
|
||||
return code;
|
||||
}
|
||||
strcpy(pWStart->functionName, "_wstart");
|
||||
tstrncpy(pWStart->functionName, "_wstart", TSDB_FUNC_NAME_LEN);
|
||||
int64_t pointer = (int64_t)pWStart;
|
||||
char name[TSDB_COL_NAME_LEN + TSDB_POINTER_PRINT_BYTES + TSDB_NAME_DELIMITER_LEN + 1] = {0};
|
||||
int32_t len = tsnprintf(name, sizeof(name) - 1, "%s.%" PRId64 "", pWStart->functionName, pointer);
|
||||
(void)taosHashBinary(name, len);
|
||||
strncpy(pWStart->node.aliasName, name, TSDB_COL_NAME_LEN - 1);
|
||||
tstrncpy(pWStart->node.aliasName, name, TSDB_COL_NAME_LEN);
|
||||
pWStart->node.resType.precision = precision;
|
||||
|
||||
code = fmGetFuncInfo(pWStart, NULL, 0);
|
||||
|
|
@ -7457,12 +7444,12 @@ static int32_t tsmaOptGeneratePlan(STSMAOptCtx* pTsmaOptCtx) {
|
|||
for (int32_t j = 0; j < pTsmaOptCtx->pScan->pTsmas->size; ++j) {
|
||||
if (taosArrayGetP(pTsmaOptCtx->pScan->pTsmas, j) == pTsma->pTsma) {
|
||||
const STsmaTargetTbInfo* ptbInfo = taosArrayGet(pTsmaOptCtx->pScan->pTsmaTargetTbInfo, j);
|
||||
strcpy(pTsma->targetTbName, ptbInfo->tableName);
|
||||
tstrncpy(pTsma->targetTbName, ptbInfo->tableName, TSDB_TABLE_NAME_LEN);
|
||||
pTsma->targetTbUid = ptbInfo->uid;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
strcpy(pTsma->targetTbName, pTsma->pTsma->targetTb);
|
||||
tstrncpy(pTsma->targetTbName, pTsma->pTsma->targetTb, TSDB_TABLE_NAME_LEN);
|
||||
pTsma->targetTbUid = pTsma->pTsma->destTbUid;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -40,9 +40,9 @@ static int32_t getSlotKey(SNode* pNode, const char* pStmtName, char** ppKey, int
|
|||
if (!*ppKey) {
|
||||
return terrno;
|
||||
}
|
||||
strcat(*ppKey, pStmtName);
|
||||
strcat(*ppKey, ".");
|
||||
strcat(*ppKey, pCol->node.aliasName);
|
||||
TAOS_STRNCAT(*ppKey, pStmtName, TSDB_TABLE_NAME_LEN);
|
||||
TAOS_STRNCAT(*ppKey, ".", 2);
|
||||
TAOS_STRNCAT(*ppKey, pCol->node.aliasName, TSDB_COL_NAME_LEN);
|
||||
*pLen = taosHashBinary(*ppKey, strlen(*ppKey));
|
||||
return code;
|
||||
} else {
|
||||
|
|
@ -50,7 +50,7 @@ static int32_t getSlotKey(SNode* pNode, const char* pStmtName, char** ppKey, int
|
|||
if (!*ppKey) {
|
||||
return terrno;
|
||||
}
|
||||
strcat(*ppKey, pCol->node.aliasName);
|
||||
TAOS_STRNCAT(*ppKey, pCol->node.aliasName, TSDB_COL_NAME_LEN);
|
||||
*pLen = strlen(*ppKey);
|
||||
return code;
|
||||
}
|
||||
|
|
@ -60,7 +60,7 @@ static int32_t getSlotKey(SNode* pNode, const char* pStmtName, char** ppKey, int
|
|||
if (!*ppKey) {
|
||||
return terrno;
|
||||
}
|
||||
strcat(*ppKey, pCol->colName);
|
||||
TAOS_STRNCAT(*ppKey, pCol->colName, TSDB_COL_NAME_LEN);
|
||||
*pLen = strlen(*ppKey);
|
||||
return code;
|
||||
}
|
||||
|
|
@ -69,9 +69,9 @@ static int32_t getSlotKey(SNode* pNode, const char* pStmtName, char** ppKey, int
|
|||
if (!*ppKey) {
|
||||
return terrno;
|
||||
}
|
||||
strcat(*ppKey, pCol->tableAlias);
|
||||
strcat(*ppKey, ".");
|
||||
strcat(*ppKey, pCol->colName);
|
||||
TAOS_STRNCAT(*ppKey, pCol->tableAlias, TSDB_TABLE_NAME_LEN);
|
||||
TAOS_STRNCAT(*ppKey, ".", 2);
|
||||
TAOS_STRNCAT(*ppKey, pCol->colName, TSDB_COL_NAME_LEN);
|
||||
*pLen = taosHashBinary(*ppKey, strlen(*ppKey));
|
||||
return code;
|
||||
} else if (QUERY_NODE_FUNCTION == nodeType(pNode)) {
|
||||
|
|
@ -84,9 +84,9 @@ static int32_t getSlotKey(SNode* pNode, const char* pStmtName, char** ppKey, int
|
|||
if (!*ppKey) {
|
||||
return terrno;
|
||||
}
|
||||
strcat(*ppKey, pStmtName);
|
||||
strcat(*ppKey, ".");
|
||||
strcat(*ppKey, ((SExprNode*)pNode)->aliasName);
|
||||
TAOS_STRNCAT(*ppKey, pStmtName, TSDB_TABLE_NAME_LEN);
|
||||
TAOS_STRNCAT(*ppKey, ".", 2);
|
||||
TAOS_STRNCAT(*ppKey, ((SExprNode*)pNode)->aliasName, TSDB_COL_NAME_LEN);
|
||||
*pLen = taosHashBinary(*ppKey, strlen(*ppKey));
|
||||
return code;
|
||||
}
|
||||
|
|
@ -94,9 +94,9 @@ static int32_t getSlotKey(SNode* pNode, const char* pStmtName, char** ppKey, int
|
|||
if (!*ppKey) {
|
||||
return terrno;
|
||||
}
|
||||
strcat(*ppKey, pVal->literal);
|
||||
strcat(*ppKey, ".");
|
||||
strcat(*ppKey, ((SExprNode*)pNode)->aliasName);
|
||||
TAOS_STRNCAT(*ppKey, pVal->literal, strlen(pVal->literal));
|
||||
TAOS_STRNCAT(*ppKey, ".", 2);
|
||||
TAOS_STRNCAT(*ppKey, ((SExprNode*)pNode)->aliasName, TSDB_COL_NAME_LEN);
|
||||
*pLen = taosHashBinary(*ppKey, strlen(*ppKey));
|
||||
return code;
|
||||
}
|
||||
|
|
@ -108,9 +108,9 @@ static int32_t getSlotKey(SNode* pNode, const char* pStmtName, char** ppKey, int
|
|||
if (!*ppKey) {
|
||||
return terrno;
|
||||
}
|
||||
strcat(*ppKey, pStmtName);
|
||||
strcat(*ppKey, ".");
|
||||
strcat(*ppKey, ((SExprNode*)pNode)->aliasName);
|
||||
TAOS_STRNCAT(*ppKey, pStmtName, TSDB_TABLE_NAME_LEN);
|
||||
TAOS_STRNCAT(*ppKey, ".", 2);
|
||||
TAOS_STRNCAT(*ppKey, ((SExprNode*)pNode)->aliasName, TSDB_COL_NAME_LEN);
|
||||
*pLen = taosHashBinary(*ppKey, strlen(*ppKey));
|
||||
return code;
|
||||
}
|
||||
|
|
@ -119,7 +119,7 @@ static int32_t getSlotKey(SNode* pNode, const char* pStmtName, char** ppKey, int
|
|||
if (!*ppKey) {
|
||||
return terrno;
|
||||
}
|
||||
strcat(*ppKey, ((SExprNode*)pNode)->aliasName);
|
||||
TAOS_STRNCAT(*ppKey, ((SExprNode*)pNode)->aliasName, TSDB_COL_NAME_LEN);
|
||||
*pLen = strlen(*ppKey);
|
||||
return code;
|
||||
}
|
||||
|
|
@ -228,7 +228,7 @@ static int32_t buildDataBlockSlots(SPhysiPlanContext* pCxt, SNodeList* pList, SD
|
|||
code = putSlotToHash(name, len, pDataBlockDesc->dataBlockId, slotId, pNode, pHash);
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
if (nodeType(pNode) == QUERY_NODE_COLUMN && ((SColumnNode*)pNode)->resIdx > 0) {
|
||||
sprintf(name + strlen(name), "_%d", ((SColumnNode*)pNode)->resIdx);
|
||||
snprintf(name + strlen(name), 16, "_%d", ((SColumnNode*)pNode)->resIdx);
|
||||
code = putSlotToHash(name, strlen(name), pDataBlockDesc->dataBlockId, slotId, pNode, pProjIdxDescHash);
|
||||
}
|
||||
}
|
||||
|
|
@ -395,7 +395,7 @@ static EDealRes doSetSlotId(SNode* pNode, void* pContext) {
|
|||
}
|
||||
SSlotIndex* pIndex = NULL;
|
||||
if (((SColumnNode*)pNode)->projRefIdx > 0) {
|
||||
sprintf(name + strlen(name), "_%d", ((SColumnNode*)pNode)->projRefIdx);
|
||||
snprintf(name + strlen(name), 16, "_%d", ((SColumnNode*)pNode)->projRefIdx);
|
||||
pIndex = taosHashGet(pCxt->pLeftProjIdxHash, name, strlen(name));
|
||||
if (!pIndex) {
|
||||
pIndex = taosHashGet(pCxt->pRightProdIdxHash, name, strlen(name));
|
||||
|
|
@ -566,9 +566,6 @@ static int32_t createScanPhysiNodeFinalize(SPhysiPlanContext* pCxt, SSubplan* pS
|
|||
if (TSDB_CODE_SUCCESS == code && NULL != pScanLogicNode->pScanPseudoCols) {
|
||||
pScanPhysiNode->pScanPseudoCols = NULL;
|
||||
code = nodesCloneList(pScanLogicNode->pScanPseudoCols, &pScanPhysiNode->pScanPseudoCols);
|
||||
if (NULL == pScanPhysiNode->pScanPseudoCols) {
|
||||
code = code;
|
||||
}
|
||||
}
|
||||
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
|
|
@ -588,9 +585,6 @@ static int32_t createScanPhysiNodeFinalize(SPhysiPlanContext* pCxt, SSubplan* pS
|
|||
if (NULL != pScanLogicNode->pTagCond) {
|
||||
pSubplan->pTagCond = NULL;
|
||||
code = nodesCloneNode(pScanLogicNode->pTagCond, &pSubplan->pTagCond);
|
||||
if (NULL == pSubplan->pTagCond) {
|
||||
code = code;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -598,9 +592,6 @@ static int32_t createScanPhysiNodeFinalize(SPhysiPlanContext* pCxt, SSubplan* pS
|
|||
if (NULL != pScanLogicNode->pTagIndexCond) {
|
||||
pSubplan->pTagIndexCond = NULL;
|
||||
code = nodesCloneNode(pScanLogicNode->pTagIndexCond, &pSubplan->pTagIndexCond);
|
||||
if (NULL == pSubplan->pTagIndexCond) {
|
||||
code = code;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1690,11 +1681,11 @@ static EDealRes collectAndRewrite(SRewritePrecalcExprsCxt* pCxt, SNode** pNode)
|
|||
SExprNode* pRewrittenExpr = (SExprNode*)pExpr;
|
||||
pCol->node.resType = pRewrittenExpr->resType;
|
||||
if ('\0' != pRewrittenExpr->aliasName[0]) {
|
||||
strcpy(pCol->colName, pRewrittenExpr->aliasName);
|
||||
tstrncpy(pCol->colName, pRewrittenExpr->aliasName, TSDB_COL_NAME_LEN);
|
||||
} else {
|
||||
snprintf(pRewrittenExpr->aliasName, sizeof(pRewrittenExpr->aliasName), "#expr_%d_%d", pCxt->planNodeId,
|
||||
pCxt->rewriteId);
|
||||
strcpy(pCol->colName, pRewrittenExpr->aliasName);
|
||||
tstrncpy(pCol->colName, pRewrittenExpr->aliasName, TSDB_COL_NAME_LEN);
|
||||
}
|
||||
nodesDestroyNode(*pNode);
|
||||
*pNode = (SNode*)pCol;
|
||||
|
|
@ -1715,7 +1706,7 @@ static int32_t rewriteValueToOperator(SRewritePrecalcExprsCxt* pCxt, SNode** pNo
|
|||
}
|
||||
SValueNode* pVal = (SValueNode*)*pNode;
|
||||
pOper->node.resType = pVal->node.resType;
|
||||
strcpy(pOper->node.aliasName, pVal->node.aliasName);
|
||||
tstrncpy(pOper->node.aliasName, pVal->node.aliasName, TSDB_COL_NAME_LEN);
|
||||
pOper->opType = OP_TYPE_ASSIGN;
|
||||
pOper->pRight = *pNode;
|
||||
*pNode = (SNode*)pOper;
|
||||
|
|
@ -1976,9 +1967,6 @@ static int32_t createInterpFuncPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pCh
|
|||
pInterpFunc->rangeInterval = pFuncLogicNode->rangeInterval;
|
||||
pInterpFunc->rangeIntervalUnit = pFuncLogicNode->rangeIntervalUnit;
|
||||
code = nodesCloneNode(pFuncLogicNode->pFillValues, &pInterpFunc->pFillValues);
|
||||
if (TSDB_CODE_SUCCESS != code) {
|
||||
code = code;
|
||||
}
|
||||
}
|
||||
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
|
|
@ -2894,7 +2882,7 @@ static int32_t createQueryInserter(SPhysiPlanContext* pCxt, SVnodeModifyLogicNod
|
|||
pInserter->tableId = pModify->tableId;
|
||||
pInserter->stableId = pModify->stableId;
|
||||
pInserter->tableType = pModify->tableType;
|
||||
strcpy(pInserter->tableName, pModify->tableName);
|
||||
tstrncpy(pInserter->tableName, pModify->tableName, TSDB_TABLE_NAME_LEN);
|
||||
pInserter->explain = (QUERY_NODE_EXPLAIN_STMT == nodeType(pCxt->pPlanCxt->pAstRoot) ? true : false);
|
||||
if (pModify->pVgroupList) {
|
||||
pInserter->vgId = pModify->pVgroupList->vgroups[0].vgId;
|
||||
|
|
@ -2906,9 +2894,6 @@ static int32_t createQueryInserter(SPhysiPlanContext* pCxt, SVnodeModifyLogicNod
|
|||
if (TSDB_CODE_SUCCESS == code) {
|
||||
pInserter->sink.pInputDataBlockDesc = NULL;
|
||||
code = nodesCloneNode((SNode*)pSubplan->pNode->pOutputDataBlockDesc, (SNode**)&pInserter->sink.pInputDataBlockDesc);
|
||||
if (NULL == pInserter->sink.pInputDataBlockDesc) {
|
||||
code = code;
|
||||
}
|
||||
}
|
||||
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
|
|
@ -2947,8 +2932,8 @@ static int32_t createDataDeleter(SPhysiPlanContext* pCxt, SVnodeModifyLogicNode*
|
|||
|
||||
pDeleter->tableId = pModify->tableId;
|
||||
pDeleter->tableType = pModify->tableType;
|
||||
strcpy(pDeleter->tableFName, pModify->tableName);
|
||||
strcpy(pDeleter->tsColName, pModify->tsColName);
|
||||
tstrncpy(pDeleter->tableFName, pModify->tableName, TSDB_TABLE_NAME_LEN);
|
||||
tstrncpy(pDeleter->tsColName, pModify->tsColName, TSDB_COL_NAME_LEN);
|
||||
pDeleter->deleteTimeRange = pModify->deleteTimeRange;
|
||||
|
||||
code = setNodeSlotId(pCxt, pRoot->pOutputDataBlockDesc->dataBlockId, -1, pModify->pAffectedRows,
|
||||
|
|
@ -2962,9 +2947,6 @@ static int32_t createDataDeleter(SPhysiPlanContext* pCxt, SVnodeModifyLogicNode*
|
|||
if (TSDB_CODE_SUCCESS == code) {
|
||||
pDeleter->sink.pInputDataBlockDesc = NULL;
|
||||
code = nodesCloneNode((SNode*)pRoot->pOutputDataBlockDesc, (SNode**)&pDeleter->sink.pInputDataBlockDesc);
|
||||
if (NULL == pDeleter->sink.pInputDataBlockDesc) {
|
||||
code = code;
|
||||
}
|
||||
}
|
||||
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
|
|
|
|||
|
|
@ -428,12 +428,12 @@ static int32_t stbSplAppendWStart(SNodeList* pFuncs, int32_t* pIndex, uint8_t pr
|
|||
if (NULL == pWStart) {
|
||||
return code;
|
||||
}
|
||||
strcpy(pWStart->functionName, "_wstart");
|
||||
tstrncpy(pWStart->functionName, "_wstart", TSDB_FUNC_NAME_LEN);
|
||||
int64_t pointer = (int64_t)pWStart;
|
||||
char name[TSDB_COL_NAME_LEN + TSDB_POINTER_PRINT_BYTES + TSDB_NAME_DELIMITER_LEN + 1] = {0};
|
||||
int32_t len = tsnprintf(name, sizeof(name) - 1, "%s.%" PRId64 "", pWStart->functionName, pointer);
|
||||
(void)taosHashBinary(name, len);
|
||||
strncpy(pWStart->node.aliasName, name, TSDB_COL_NAME_LEN - 1);
|
||||
tstrncpy(pWStart->node.aliasName, name, TSDB_COL_NAME_LEN);
|
||||
pWStart->node.resType.precision = precision;
|
||||
|
||||
code = fmGetFuncInfo(pWStart, NULL, 0);
|
||||
|
|
@ -460,12 +460,12 @@ static int32_t stbSplAppendWEnd(SWindowLogicNode* pWin, int32_t* pIndex) {
|
|||
if (NULL == pWEnd) {
|
||||
return code;
|
||||
}
|
||||
strcpy(pWEnd->functionName, "_wend");
|
||||
tstrncpy(pWEnd->functionName, "_wend", TSDB_FUNC_NAME_LEN);
|
||||
int64_t pointer = (int64_t)pWEnd;
|
||||
char name[TSDB_COL_NAME_LEN + TSDB_POINTER_PRINT_BYTES + TSDB_NAME_DELIMITER_LEN + 1] = {0};
|
||||
int32_t len = tsnprintf(name, sizeof(name) - 1, "%s.%" PRId64 "", pWEnd->functionName, pointer);
|
||||
(void)taosHashBinary(name, len);
|
||||
strncpy(pWEnd->node.aliasName, name, TSDB_COL_NAME_LEN - 1);
|
||||
tstrncpy(pWEnd->node.aliasName, name, TSDB_COL_NAME_LEN);
|
||||
|
||||
code = fmGetFuncInfo(pWEnd, NULL, 0);
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
|
|
@ -1135,8 +1135,8 @@ static int32_t stbSplAggNodeCreateMerge(SSplitContext* pCtx, SStableSplitInfo* p
|
|||
if (!nodesEqualNode(pParam, (SNode*)pCol)) continue;
|
||||
|
||||
// use the colName of group_key func to make sure finding the right slot id for merge keys.
|
||||
strcpy(pCol->colName, pFunc->node.aliasName);
|
||||
strcpy(pCol->node.aliasName, pFunc->node.aliasName);
|
||||
tstrncpy(pCol->colName, pFunc->node.aliasName, TSDB_COL_NAME_LEN);
|
||||
tstrncpy(pCol->node.aliasName, pFunc->node.aliasName, TSDB_COL_NAME_LEN);
|
||||
memset(pCol->tableAlias, 0, TSDB_TABLE_NAME_LEN);
|
||||
break;
|
||||
}
|
||||
|
|
@ -1265,15 +1265,15 @@ static int32_t stbSplCreateColumnNode(SExprNode* pExpr, SNode** ppNode) {
|
|||
return code;
|
||||
}
|
||||
if (QUERY_NODE_COLUMN == nodeType(pExpr)) {
|
||||
strcpy(pCol->dbName, ((SColumnNode*)pExpr)->dbName);
|
||||
strcpy(pCol->tableName, ((SColumnNode*)pExpr)->tableName);
|
||||
strcpy(pCol->tableAlias, ((SColumnNode*)pExpr)->tableAlias);
|
||||
strcpy(pCol->colName, ((SColumnNode*)pExpr)->colName);
|
||||
tstrncpy(pCol->dbName, ((SColumnNode*)pExpr)->dbName, TSDB_DB_NAME_LEN);
|
||||
tstrncpy(pCol->tableName, ((SColumnNode*)pExpr)->tableName, TSDB_TABLE_NAME_LEN);
|
||||
tstrncpy(pCol->tableAlias, ((SColumnNode*)pExpr)->tableAlias, TSDB_TABLE_NAME_LEN);
|
||||
tstrncpy(pCol->colName, ((SColumnNode*)pExpr)->colName, TSDB_COL_NAME_LEN);
|
||||
} else {
|
||||
strcpy(pCol->colName, pExpr->aliasName);
|
||||
tstrncpy(pCol->colName, pExpr->aliasName, TSDB_COL_NAME_LEN);
|
||||
}
|
||||
strcpy(pCol->node.aliasName, pExpr->aliasName);
|
||||
strcpy(pCol->node.userAlias, pExpr->userAlias);
|
||||
tstrncpy(pCol->node.aliasName, pExpr->aliasName, TSDB_COL_NAME_LEN);
|
||||
tstrncpy(pCol->node.userAlias, pExpr->userAlias, TSDB_COL_NAME_LEN);
|
||||
pCol->node.resType = pExpr->resType;
|
||||
*ppNode = (SNode*)pCol;
|
||||
return code;
|
||||
|
|
@ -1358,9 +1358,6 @@ static int32_t stbSplCreatePartSortNode(SSortLogicNode* pSort, SLogicNode** pOut
|
|||
int32_t code = TSDB_CODE_SUCCESS;
|
||||
SSortLogicNode* pPartSort = NULL;
|
||||
code = nodesCloneNode((SNode*)pSort, (SNode**)&pPartSort);
|
||||
if (NULL == pPartSort) {
|
||||
code = code;
|
||||
}
|
||||
|
||||
SNodeList* pMergeKeys = NULL;
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
|
|
@ -1541,9 +1538,6 @@ static int32_t stbSplCreateMergeScanNode(SScanLogicNode* pScan, SLogicNode** pOu
|
|||
int32_t code = TSDB_CODE_SUCCESS;
|
||||
SScanLogicNode* pMergeScan = NULL;
|
||||
code = nodesCloneNode((SNode*)pScan, (SNode**)&pMergeScan);
|
||||
if (NULL == pMergeScan) {
|
||||
code = code;
|
||||
}
|
||||
|
||||
SNodeList* pMergeKeys = NULL;
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
|
|
|
|||
|
|
@ -68,14 +68,14 @@ static EDealRes doCreateColumn(SNode* pNode, void* pContext) {
|
|||
return DEAL_RES_ERROR;
|
||||
}
|
||||
pCol->node.resType = pExpr->resType;
|
||||
strcpy(pCol->colName, pExpr->aliasName);
|
||||
tstrncpy(pCol->colName, pExpr->aliasName, TSDB_COL_NAME_LEN);
|
||||
if (QUERY_NODE_FUNCTION == nodeType(pNode)) {
|
||||
SFunctionNode* pFunc = (SFunctionNode*)pNode;
|
||||
if (pFunc->funcType == FUNCTION_TYPE_TBNAME) {
|
||||
SValueNode* pVal = (SValueNode*)nodesListGetNode(pFunc->pParameterList, 0);
|
||||
if (NULL != pVal) {
|
||||
strcpy(pCol->tableAlias, pVal->literal);
|
||||
strcpy(pCol->tableName, pVal->literal);
|
||||
tstrncpy(pCol->tableAlias, pVal->literal, TSDB_TABLE_NAME_LEN);
|
||||
tstrncpy(pCol->tableName, pVal->literal, TSDB_TABLE_NAME_LEN);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -636,9 +636,9 @@ SFunctionNode* createGroupKeyAggFunc(SColumnNode* pGroupCol) {
|
|||
SFunctionNode* pFunc = NULL;
|
||||
int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc);
|
||||
if (pFunc) {
|
||||
strcpy(pFunc->functionName, "_group_key");
|
||||
strcpy(pFunc->node.aliasName, pGroupCol->node.aliasName);
|
||||
strcpy(pFunc->node.userAlias, pGroupCol->node.userAlias);
|
||||
tstrncpy(pFunc->functionName, "_group_key", TSDB_FUNC_NAME_LEN);
|
||||
tstrncpy(pFunc->node.aliasName, pGroupCol->node.aliasName, TSDB_COL_NAME_LEN);
|
||||
tstrncpy(pFunc->node.userAlias, pGroupCol->node.userAlias, TSDB_COL_NAME_LEN);
|
||||
SNode* pNew = NULL;
|
||||
code = nodesCloneNode((SNode*)pGroupCol, &pNew);
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
|
|
@ -655,7 +655,7 @@ SFunctionNode* createGroupKeyAggFunc(SColumnNode* pGroupCol) {
|
|||
char name[TSDB_FUNC_NAME_LEN + TSDB_NAME_DELIMITER_LEN + TSDB_POINTER_PRINT_BYTES + 1] = {0};
|
||||
int32_t len = tsnprintf(name, sizeof(name) - 1, "%s.%p", pFunc->functionName, pFunc);
|
||||
(void)taosHashBinary(name, len);
|
||||
strncpy(pFunc->node.aliasName, name, TSDB_COL_NAME_LEN - 1);
|
||||
tstrncpy(pFunc->node.aliasName, name, TSDB_COL_NAME_LEN);
|
||||
}
|
||||
}
|
||||
if (TSDB_CODE_SUCCESS != code) {
|
||||
|
|
|
|||
|
|
@ -1249,7 +1249,6 @@ EDealRes sclRewriteFunction(SNode **pNode, SScalarCtx *ctx) {
|
|||
ctx->code = TSDB_CODE_OUT_OF_MEMORY;
|
||||
return DEAL_RES_ERROR;
|
||||
}
|
||||
res->node.resType.bytes = varDataTLen(output.columnData->pData);
|
||||
(void)memcpy(res->datum.p, output.columnData->pData, varDataTLen(output.columnData->pData));
|
||||
} else {
|
||||
ctx->code = nodesSetValueNodeValue(res, output.columnData->pData);
|
||||
|
|
|
|||
|
|
@ -1129,7 +1129,11 @@ int32_t schLaunchRemoteTask(SSchJob *pJob, SSchTask *pTask) {
|
|||
int32_t schLaunchLocalTask(SSchJob *pJob, SSchTask *pTask) {
|
||||
// SCH_ERR_JRET(schSetTaskCandidateAddrs(pJob, pTask));
|
||||
if (NULL == schMgmt.queryMgmt) {
|
||||
SCH_ERR_RET(qWorkerInit(NODE_TYPE_CLIENT, CLIENT_HANDLE, (void **)&schMgmt.queryMgmt, NULL));
|
||||
void* p = NULL;
|
||||
SCH_ERR_RET(qWorkerInit(NODE_TYPE_CLIENT, CLIENT_HANDLE, &p, NULL));
|
||||
if (atomic_val_compare_exchange_ptr(&schMgmt.queryMgmt, NULL, p)) {
|
||||
qWorkerDestroy(&p);
|
||||
}
|
||||
}
|
||||
|
||||
SArray *explainRes = NULL;
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@ extern "C" {
|
|||
#define META_HB_CHECK_INTERVAL 200
|
||||
#define META_HB_SEND_IDLE_COUNTER 25 // send hb every 5 sec
|
||||
#define STREAM_TASK_KEY_LEN ((sizeof(int64_t)) << 1)
|
||||
#define STREAM_TASK_QUEUE_CAPACITY 20480
|
||||
#define STREAM_TASK_QUEUE_CAPACITY 5120
|
||||
#define STREAM_TASK_QUEUE_CAPACITY_IN_SIZE (30)
|
||||
|
||||
// clang-format off
|
||||
|
|
|
|||
|
|
@ -4378,7 +4378,6 @@ void streamStateParTagSeekKeyNext_rocksdb(SStreamState* pState, const int64_t gr
|
|||
}
|
||||
|
||||
int32_t streamStateParTagGetKVByCur_rocksdb(SStreamStateCur* pCur, int64_t* pGroupId, const void** pVal, int32_t* pVLen) {
|
||||
stDebug("streamStateFillGetKVByCur_rocksdb");
|
||||
if (!pCur) {
|
||||
return -1;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -613,7 +613,6 @@ int32_t streamTaskUpdateTaskCheckpointInfo(SStreamTask* pTask, bool restored, SV
|
|||
|
||||
{ // destroy the related fill-history tasks
|
||||
// drop task should not in the meta-lock, and drop the related fill-history task now
|
||||
streamMetaWUnLock(pMeta);
|
||||
if (pReq->dropRelHTask) {
|
||||
code = streamMetaUnregisterTask(pMeta, pReq->hStreamId, pReq->hTaskId);
|
||||
int32_t numOfTasks = streamMetaGetNumOfTasks(pMeta);
|
||||
|
|
@ -621,7 +620,6 @@ int32_t streamTaskUpdateTaskCheckpointInfo(SStreamTask* pTask, bool restored, SV
|
|||
id, vgId, pReq->taskId, numOfTasks);
|
||||
}
|
||||
|
||||
streamMetaWLock(pMeta);
|
||||
if (pReq->dropRelHTask) {
|
||||
code = streamMetaCommit(pMeta);
|
||||
}
|
||||
|
|
@ -656,9 +654,11 @@ int32_t streamTaskUpdateTaskCheckpointInfo(SStreamTask* pTask, bool restored, SV
|
|||
pInfo->processedVer <= pReq->checkpointVer);
|
||||
|
||||
if (!valid) {
|
||||
stFatal("invalid checkpoint id check, current checkpointId:%" PRId64 " checkpointVer:%" PRId64
|
||||
" processedVer:%" PRId64 " req checkpointId:%" PRId64 " checkpointVer:%" PRId64,
|
||||
pInfo->checkpointId, pInfo->checkpointVer, pInfo->processedVer, pReq->checkpointId, pReq->checkpointVer);
|
||||
stFatal("s-task:%s invalid checkpointId update info recv, current checkpointId:%" PRId64 " checkpointVer:%" PRId64
|
||||
" processedVer:%" PRId64 " req checkpointId:%" PRId64 " checkpointVer:%" PRId64 " discard it",
|
||||
id, pInfo->checkpointId, pInfo->checkpointVer, pInfo->processedVer, pReq->checkpointId,
|
||||
pReq->checkpointVer);
|
||||
streamMutexUnlock(&pTask->lock);
|
||||
return TSDB_CODE_STREAM_INTERNAL_ERROR;
|
||||
}
|
||||
|
||||
|
|
@ -695,8 +695,6 @@ int32_t streamTaskUpdateTaskCheckpointInfo(SStreamTask* pTask, bool restored, SV
|
|||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
streamMetaWUnLock(pMeta);
|
||||
|
||||
// drop task should not in the meta-lock, and drop the related fill-history task now
|
||||
if (pReq->dropRelHTask) {
|
||||
code = streamMetaUnregisterTask(pMeta, pReq->hStreamId, pReq->hTaskId);
|
||||
|
|
@ -705,9 +703,7 @@ int32_t streamTaskUpdateTaskCheckpointInfo(SStreamTask* pTask, bool restored, SV
|
|||
(int32_t)pReq->hTaskId, numOfTasks);
|
||||
}
|
||||
|
||||
streamMetaWLock(pMeta);
|
||||
code = streamMetaCommit(pMeta);
|
||||
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -522,7 +522,10 @@ static int32_t doSetStreamInputBlock(SStreamTask* pTask, const void* pInput, int
|
|||
if (pItem->type == STREAM_INPUT__GET_RES) {
|
||||
const SStreamTrigger* pTrigger = (const SStreamTrigger*)pInput;
|
||||
code = qSetMultiStreamInput(pExecutor, pTrigger->pBlock, 1, STREAM_INPUT__DATA_BLOCK);
|
||||
|
||||
if (pTask->info.trigger == STREAM_TRIGGER_FORCE_WINDOW_CLOSE) {
|
||||
stDebug("s-task:%s set force_window_close as source block, skey:%"PRId64, id, pTrigger->pBlock->info.window.skey);
|
||||
(*pVer) = pTrigger->pBlock->info.window.skey;
|
||||
}
|
||||
} else if (pItem->type == STREAM_INPUT__DATA_SUBMIT) {
|
||||
const SStreamDataSubmit* pSubmit = (const SStreamDataSubmit*)pInput;
|
||||
code = qSetMultiStreamInput(pExecutor, &pSubmit->submit, 1, STREAM_INPUT__DATA_SUBMIT);
|
||||
|
|
@ -671,7 +674,7 @@ static int32_t doStreamTaskExecImpl(SStreamTask* pTask, SStreamQueueItem* pBlock
|
|||
|
||||
doRecordThroughput(&pTask->execInfo, totalBlocks, totalSize, blockSize, st, pTask->id.idStr);
|
||||
|
||||
// update the currentVer if processing the submit blocks.
|
||||
// update the currentVer if processing the submitted blocks.
|
||||
if (!(pInfo->checkpointVer <= pInfo->nextProcessVer && ver >= pInfo->checkpointVer)) {
|
||||
stError("s-task:%s invalid info, checkpointVer:%" PRId64 ", nextProcessVer:%" PRId64 " currentVer:%" PRId64, id,
|
||||
pInfo->checkpointVer, pInfo->nextProcessVer, ver);
|
||||
|
|
@ -688,6 +691,34 @@ static int32_t doStreamTaskExecImpl(SStreamTask* pTask, SStreamQueueItem* pBlock
|
|||
return code;
|
||||
}
|
||||
|
||||
// do nothing after sync executor state to storage backend, untill checkpoint is completed.
|
||||
static int32_t doHandleChkptBlock(SStreamTask* pTask) {
|
||||
int32_t code = 0;
|
||||
const char* id = pTask->id.idStr;
|
||||
|
||||
streamMutexLock(&pTask->lock);
|
||||
SStreamTaskState pState = streamTaskGetStatus(pTask);
|
||||
if (pState.state == TASK_STATUS__CK) { // todo other thread may change the status
|
||||
stDebug("s-task:%s checkpoint block received, set status:%s", id, pState.name);
|
||||
code = streamTaskBuildCheckpoint(pTask); // ignore this error msg, and continue
|
||||
} else { // todo refactor
|
||||
if (pTask->info.taskLevel == TASK_LEVEL__SOURCE) {
|
||||
code = streamTaskSendCheckpointSourceRsp(pTask);
|
||||
} else {
|
||||
code = streamTaskSendCheckpointReadyMsg(pTask);
|
||||
}
|
||||
|
||||
if (code != TSDB_CODE_SUCCESS) {
|
||||
// todo: let's retry send rsp to upstream/mnode
|
||||
stError("s-task:%s failed to send checkpoint rsp to upstream, checkpointId:%d, code:%s", id, 0,
|
||||
tstrerror(code));
|
||||
}
|
||||
}
|
||||
|
||||
streamMutexUnlock(&pTask->lock);
|
||||
return code;
|
||||
}
|
||||
|
||||
int32_t flushStateDataInExecutor(SStreamTask* pTask, SStreamQueueItem* pCheckpointBlock) {
|
||||
const char* id = pTask->id.idStr;
|
||||
|
||||
|
|
@ -832,36 +863,16 @@ static int32_t doStreamExecTask(SStreamTask* pTask) {
|
|||
}
|
||||
}
|
||||
|
||||
if (type != STREAM_INPUT__CHECKPOINT) {
|
||||
if (type == STREAM_INPUT__CHECKPOINT) {
|
||||
code = doHandleChkptBlock(pTask);
|
||||
streamFreeQitem(pInput);
|
||||
return code;
|
||||
} else {
|
||||
code = doStreamTaskExecImpl(pTask, pInput, numOfBlocks);
|
||||
streamFreeQitem(pInput);
|
||||
if (code) {
|
||||
return code;
|
||||
}
|
||||
} else { // todo other thread may change the status
|
||||
// do nothing after sync executor state to storage backend, untill the vnode-level checkpoint is completed.
|
||||
streamMutexLock(&pTask->lock);
|
||||
SStreamTaskState pState = streamTaskGetStatus(pTask);
|
||||
if (pState.state == TASK_STATUS__CK) {
|
||||
stDebug("s-task:%s checkpoint block received, set status:%s", id, pState.name);
|
||||
code = streamTaskBuildCheckpoint(pTask); // ignore this error msg, and continue
|
||||
} else { // todo refactor
|
||||
if (pTask->info.taskLevel == TASK_LEVEL__SOURCE) {
|
||||
code = streamTaskSendCheckpointSourceRsp(pTask);
|
||||
} else {
|
||||
code = streamTaskSendCheckpointReadyMsg(pTask);
|
||||
}
|
||||
|
||||
if (code != TSDB_CODE_SUCCESS) {
|
||||
// todo: let's retry send rsp to upstream/mnode
|
||||
stError("s-task:%s failed to send checkpoint rsp to upstream, checkpointId:%d, code:%s", id, 0,
|
||||
tstrerror(code));
|
||||
}
|
||||
}
|
||||
|
||||
streamMutexUnlock(&pTask->lock);
|
||||
streamFreeQitem(pInput);
|
||||
return code;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -501,8 +501,6 @@ _err:
|
|||
void streamMetaInitBackend(SStreamMeta* pMeta) {
|
||||
pMeta->streamBackend = streamBackendInit(pMeta->path, pMeta->chkpId, pMeta->vgId);
|
||||
if (pMeta->streamBackend == NULL) {
|
||||
streamMetaWUnLock(pMeta);
|
||||
|
||||
while (1) {
|
||||
streamMetaWLock(pMeta);
|
||||
pMeta->streamBackend = streamBackendInit(pMeta->path, pMeta->chkpId, pMeta->vgId);
|
||||
|
|
@ -908,8 +906,6 @@ int32_t streamMetaUnregisterTask(SStreamMeta* pMeta, int64_t streamId, int32_t t
|
|||
int32_t code = 0;
|
||||
STaskId id = {.streamId = streamId, .taskId = taskId};
|
||||
|
||||
streamMetaWLock(pMeta);
|
||||
|
||||
code = streamMetaAcquireTaskUnsafe(pMeta, &id, &pTask);
|
||||
if (code == 0) {
|
||||
// desc the paused task counter
|
||||
|
|
@ -958,10 +954,8 @@ int32_t streamMetaUnregisterTask(SStreamMeta* pMeta, int64_t streamId, int32_t t
|
|||
}
|
||||
|
||||
streamMetaReleaseTask(pMeta, pTask);
|
||||
streamMetaWUnLock(pMeta);
|
||||
} else {
|
||||
stDebug("vgId:%d failed to find the task:0x%x, it may have been dropped already", vgId, taskId);
|
||||
streamMetaWUnLock(pMeta);
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
|
|
|||
|
|
@ -211,6 +211,7 @@ static int32_t doCreateForceWindowTrigger(SStreamTask* pTask, int32_t* pNextTrig
|
|||
const char* id = pTask->id.idStr;
|
||||
int8_t precision = pTask->info.interval.precision;
|
||||
SStreamTrigger* pTrigger = NULL;
|
||||
bool isFull = false;
|
||||
|
||||
while (1) {
|
||||
code = streamCreateForcewindowTrigger(&pTrigger, pTask->info.delaySchedParam, &pTask->info.interval,
|
||||
|
|
@ -233,7 +234,6 @@ static int32_t doCreateForceWindowTrigger(SStreamTask* pTask, int32_t* pNextTrig
|
|||
|
||||
// check whether the time window gaps exist or not
|
||||
int64_t now = taosGetTimestamp(precision);
|
||||
int64_t ekey = pTrigger->pBlock->info.window.skey + pTask->info.interval.interval;
|
||||
|
||||
// there are gaps, needs to be filled
|
||||
STimeWindow w = pTrigger->pBlock->info.window;
|
||||
|
|
@ -245,13 +245,18 @@ static int32_t doCreateForceWindowTrigger(SStreamTask* pTask, int32_t* pNextTrig
|
|||
}
|
||||
|
||||
pTask->status.latestForceWindow = w;
|
||||
if (ekey + pTask->info.watermark + pTask->info.interval.interval > now) {
|
||||
int64_t prev = convertTimePrecision(*pNextTrigger, precision, TSDB_TIME_PRECISION_MILLI);
|
||||
isFull = streamQueueIsFull(pTask->inputq.queue);
|
||||
|
||||
if ((w.ekey + pTask->info.watermark + pTask->info.interval.interval > now) || isFull) {
|
||||
int64_t prev = convertTimePrecision(*pNextTrigger, precision, TSDB_TIME_PRECISION_MILLI);
|
||||
if (!isFull) {
|
||||
*pNextTrigger = w.ekey + pTask->info.watermark + pTask->info.interval.interval - now;
|
||||
}
|
||||
|
||||
*pNextTrigger = ekey + pTask->info.watermark + pTask->info.interval.interval - now;
|
||||
*pNextTrigger = convertTimePrecision(*pNextTrigger, precision, TSDB_TIME_PRECISION_MILLI);
|
||||
stDebug("s-task:%s generate %d time window(s), trigger delay adjust from %" PRId64 " to %d", id, num, prev,
|
||||
*pNextTrigger);
|
||||
pTask->chkInfo.nextProcessVer = w.ekey + pTask->info.interval.interval;
|
||||
stDebug("s-task:%s generate %d time window(s), trigger delay adjust from %" PRId64 " to %d, set ver:%" PRId64, id,
|
||||
num, prev, *pNextTrigger, pTask->chkInfo.nextProcessVer);
|
||||
return code;
|
||||
} else {
|
||||
stDebug("s-task:%s gap exist for force_window_close, current force_window_skey:%" PRId64, id, w.skey);
|
||||
|
|
@ -308,7 +313,7 @@ void streamTaskSchedHelper(void* param, void* tmrId) {
|
|||
}
|
||||
|
||||
if (streamTaskGetStatus(pTask).state == TASK_STATUS__CK) {
|
||||
nextTrigger = TRIGGER_RECHECK_INTERVAL; // retry in 10 seec
|
||||
nextTrigger = TRIGGER_RECHECK_INTERVAL; // retry in 10 sec
|
||||
stDebug("s-task:%s in checkpoint procedure, not retrieve result, next:%dms", id, TRIGGER_RECHECK_INTERVAL);
|
||||
} else {
|
||||
if (pTask->info.trigger == STREAM_TRIGGER_FORCE_WINDOW_CLOSE && pTask->info.taskLevel == TASK_LEVEL__SOURCE) {
|
||||
|
|
|
|||
|
|
@ -947,6 +947,7 @@ int32_t recoverSession(SStreamFileState* pFileState, int64_t ckId) {
|
|||
}
|
||||
|
||||
SRowBuffPos* pPos = createSessionWinBuff(pFileState, &key, pVal, &vlen);
|
||||
pPos->beUsed = false;
|
||||
winRes = putSessionWinResultBuff(pFileState, pPos);
|
||||
if (winRes != TSDB_CODE_SUCCESS) {
|
||||
break;
|
||||
|
|
@ -1008,6 +1009,7 @@ int32_t recoverSnapshot(SStreamFileState* pFileState, int64_t ckId) {
|
|||
memcpy(pNewPos->pRowBuff, pVal, vlen);
|
||||
taosMemoryFreeClear(pVal);
|
||||
pNewPos->beFlushed = true;
|
||||
pNewPos->beUsed = false;
|
||||
qDebug("===stream=== read checkpoint state from disc. %s", __func__);
|
||||
code = tSimpleHashPut(pFileState->rowStateBuff, pNewPos->pKey, pFileState->keyLen, &pNewPos, POINTER_BYTES);
|
||||
if (code != TSDB_CODE_SUCCESS) {
|
||||
|
|
@ -1090,6 +1092,7 @@ int32_t recoverFillSnapshot(SStreamFileState* pFileState, int64_t ckId) {
|
|||
|
||||
if (vlen != pFileState->rowSize) {
|
||||
qError("row size mismatch, expect:%d, actual:%d", pFileState->rowSize, vlen);
|
||||
destroyRowBuffPos(pNewPos);
|
||||
code = TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;
|
||||
taosMemoryFreeClear(pVal);
|
||||
QUERY_CHECK_CODE(code, lino, _end);
|
||||
|
|
@ -1098,6 +1101,7 @@ int32_t recoverFillSnapshot(SStreamFileState* pFileState, int64_t ckId) {
|
|||
memcpy(pNewPos->pRowBuff, pVal, vlen);
|
||||
taosMemoryFreeClear(pVal);
|
||||
pNewPos->beFlushed = true;
|
||||
pNewPos->beUsed = false;
|
||||
qDebug("===stream=== read checkpoint state from disc. %s", __func__);
|
||||
winRes = tSimpleHashPut(pFileState->rowStateBuff, pNewPos->pKey, pFileState->keyLen, &pNewPos, POINTER_BYTES);
|
||||
if (winRes != TSDB_CODE_SUCCESS) {
|
||||
|
|
@ -1228,6 +1232,8 @@ void setFillInfo(SStreamFileState* pFileState) {
|
|||
}
|
||||
|
||||
void clearExpiredState(SStreamFileState* pFileState) {
|
||||
int32_t code = TSDB_CODE_SUCCESS;
|
||||
int32_t lino = 0;
|
||||
SSHashObj* pSearchBuff = pFileState->searchBuff;
|
||||
void* pIte = NULL;
|
||||
int32_t iter = 0;
|
||||
|
|
@ -1246,6 +1252,13 @@ void clearExpiredState(SStreamFileState* pFileState) {
|
|||
}
|
||||
taosArrayRemoveBatch(pWinStates, 0, size - 1, NULL);
|
||||
}
|
||||
code = clearRowBuff(pFileState);
|
||||
QUERY_CHECK_CODE(code, lino, _end);
|
||||
|
||||
_end:
|
||||
if (code != TSDB_CODE_SUCCESS) {
|
||||
qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
|
||||
}
|
||||
}
|
||||
|
||||
int32_t getStateSearchRowBuff(SStreamFileState* pFileState, const SWinKey* pKey, void** pVal, int32_t* pVLen,
|
||||
|
|
|
|||
|
|
@ -1464,7 +1464,7 @@ int32_t syncNodeRestore(SSyncNode* pSyncNode) {
|
|||
|
||||
// if (endIndex != lastVer + 1) return TSDB_CODE_SYN_INTERNAL_ERROR;
|
||||
pSyncNode->commitIndex = TMAX(pSyncNode->commitIndex, commitIndex);
|
||||
sInfo("vgId:%d, restore sync until commitIndex:%" PRId64, pSyncNode->vgId, pSyncNode->commitIndex);
|
||||
sInfo("vgId:%d, restore began, and keep syncing until commitIndex:%" PRId64, pSyncNode->vgId, pSyncNode->commitIndex);
|
||||
|
||||
if (pSyncNode->fsmState != SYNC_FSM_STATE_INCOMPLETE &&
|
||||
(code = syncLogBufferCommit(pSyncNode->pLogBuf, pSyncNode, pSyncNode->commitIndex)) < 0) {
|
||||
|
|
|
|||
|
|
@ -19,7 +19,6 @@
|
|||
typedef union {
|
||||
volatile int64_t i;
|
||||
volatile double d;
|
||||
//double d;
|
||||
} double_number;
|
||||
|
||||
#ifdef WINDOWS
|
||||
|
|
@ -345,7 +344,7 @@ void atomic_store_64(int64_t volatile* ptr, int64_t val) {
|
|||
#endif
|
||||
}
|
||||
|
||||
double atomic_store_double(double volatile *ptr, double val){
|
||||
void atomic_store_double(double volatile* ptr, double val) {
|
||||
for (;;) {
|
||||
double_number old_num = {0};
|
||||
old_num.d = *ptr; // current old value
|
||||
|
|
@ -354,9 +353,9 @@ double atomic_store_double(double volatile *ptr, double val){
|
|||
new_num.d = val;
|
||||
|
||||
double_number ret_num = {0};
|
||||
ret_num.i = atomic_val_compare_exchange_64((volatile int64_t *)ptr, old_num.i, new_num.i);
|
||||
ret_num.i = atomic_val_compare_exchange_64((volatile int64_t*)ptr, old_num.i, new_num.i);
|
||||
|
||||
if (ret_num.i == old_num.i) return ret_num.d;
|
||||
if (ret_num.i == old_num.i) return;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -414,16 +413,16 @@ int64_t atomic_exchange_64(int64_t volatile* ptr, int64_t val) {
|
|||
#endif
|
||||
}
|
||||
|
||||
double atomic_exchange_double(double volatile *ptr, int64_t val){
|
||||
double atomic_exchange_double(double volatile* ptr, double val) {
|
||||
for (;;) {
|
||||
double_number old_num = {0};
|
||||
old_num.d = *ptr; // current old value
|
||||
|
||||
double_number new_num = {0};
|
||||
int64_t iNew = val;
|
||||
new_num.d = val;
|
||||
|
||||
double_number ret_num = {0};
|
||||
ret_num.i = atomic_val_compare_exchange_64((volatile int64_t *)ptr, old_num.i, new_num.i);
|
||||
ret_num.i = atomic_val_compare_exchange_64((volatile int64_t*)ptr, old_num.i, new_num.i);
|
||||
|
||||
if (ret_num.i == old_num.i) {
|
||||
return ret_num.d;
|
||||
|
|
@ -589,7 +588,7 @@ int64_t atomic_fetch_add_64(int64_t volatile* ptr, int64_t val) {
|
|||
#endif
|
||||
}
|
||||
|
||||
double atomic_fetch_add_double(double volatile *ptr, double val){
|
||||
double atomic_fetch_add_double(double volatile* ptr, double val) {
|
||||
for (;;) {
|
||||
double_number old_num = {0};
|
||||
old_num.d = *ptr; // current old value
|
||||
|
|
@ -598,13 +597,13 @@ double atomic_fetch_add_double(double volatile *ptr, double val){
|
|||
new_num.d = old_num.d + val;
|
||||
|
||||
double_number ret_num = {0};
|
||||
ret_num.i = atomic_val_compare_exchange_64((volatile int64_t *)ptr, old_num.i, new_num.i);
|
||||
ret_num.i = atomic_val_compare_exchange_64((volatile int64_t*)ptr, old_num.i, new_num.i);
|
||||
|
||||
if (ret_num.i == old_num.i) return ret_num.d;
|
||||
}
|
||||
}
|
||||
|
||||
void* atomic_fetch_add_ptr(void* ptr, void* val) {
|
||||
void* atomic_fetch_add_ptr(void* ptr, int64_t val) {
|
||||
#ifdef WINDOWS
|
||||
return _InterlockedExchangePointer((void* volatile*)(ptr), (void*)(val));
|
||||
#elif defined(_TD_NINGSI_60)
|
||||
|
|
@ -710,7 +709,7 @@ int64_t atomic_fetch_sub_64(int64_t volatile* ptr, int64_t val) {
|
|||
#endif
|
||||
}
|
||||
|
||||
double atomic_fetch_sub_double(double volatile *ptr, double val){
|
||||
double atomic_fetch_sub_double(double volatile* ptr, double val) {
|
||||
for (;;) {
|
||||
double_number old_num = {0};
|
||||
old_num.d = *ptr; // current old value
|
||||
|
|
@ -719,13 +718,13 @@ double atomic_fetch_sub_double(double volatile *ptr, double val){
|
|||
new_num.d = old_num.d - val;
|
||||
|
||||
double_number ret_num = {0};
|
||||
ret_num.i = atomic_val_compare_exchange_64((volatile int64_t *)ptr, old_num.i, new_num.i);
|
||||
ret_num.i = atomic_val_compare_exchange_64((volatile int64_t*)ptr, old_num.i, new_num.i);
|
||||
|
||||
if (ret_num.i == old_num.i) return ret_num.d;
|
||||
}
|
||||
}
|
||||
|
||||
void* atomic_fetch_sub_ptr(void* ptr, void* val) {
|
||||
void* atomic_fetch_sub_ptr(void* ptr, int64_t val) {
|
||||
#ifdef WINDOWS
|
||||
return interlocked_fetch_sub_ptr(ptr, val);
|
||||
#elif defined(_TD_NINGSI_60)
|
||||
|
|
@ -777,7 +776,7 @@ int64_t atomic_and_fetch_64(int64_t volatile* ptr, int64_t val) {
|
|||
#endif
|
||||
}
|
||||
|
||||
void* atomic_and_fetch_ptr(void* ptr, void* val) {
|
||||
void* atomic_and_fetch_ptr(void* ptr, int64_t val) {
|
||||
#ifdef WINDOWS
|
||||
return interlocked_and_fetch_ptr((void* volatile*)(ptr), (void*)(val));
|
||||
#elif defined(_TD_NINGSI_60)
|
||||
|
|
@ -829,7 +828,7 @@ int64_t atomic_fetch_and_64(int64_t volatile* ptr, int64_t val) {
|
|||
#endif
|
||||
}
|
||||
|
||||
void* atomic_fetch_and_ptr(void* ptr, void* val) {
|
||||
void* atomic_fetch_and_ptr(void* ptr, int64_t val) {
|
||||
#ifdef WINDOWS
|
||||
return interlocked_fetch_and_ptr((void* volatile*)(ptr), (void*)(val));
|
||||
#elif defined(_TD_NINGSI_60)
|
||||
|
|
@ -881,7 +880,7 @@ int64_t atomic_or_fetch_64(int64_t volatile* ptr, int64_t val) {
|
|||
#endif
|
||||
}
|
||||
|
||||
void* atomic_or_fetch_ptr(void* ptr, void* val) {
|
||||
void* atomic_or_fetch_ptr(void* ptr, int64_t val) {
|
||||
#ifdef WINDOWS
|
||||
return interlocked_or_fetch_ptr((void* volatile*)(ptr), (void*)(val));
|
||||
#elif defined(_TD_NINGSI_60)
|
||||
|
|
@ -933,7 +932,7 @@ int64_t atomic_fetch_or_64(int64_t volatile* ptr, int64_t val) {
|
|||
#endif
|
||||
}
|
||||
|
||||
void* atomic_fetch_or_ptr(void* ptr, void* val) {
|
||||
void* atomic_fetch_or_ptr(void* ptr, int64_t val) {
|
||||
#ifdef WINDOWS
|
||||
return interlocked_fetch_or_ptr((void* volatile*)(ptr), (void*)(val));
|
||||
#elif defined(_TD_NINGSI_60)
|
||||
|
|
@ -985,7 +984,7 @@ int64_t atomic_xor_fetch_64(int64_t volatile* ptr, int64_t val) {
|
|||
#endif
|
||||
}
|
||||
|
||||
void* atomic_xor_fetch_ptr(void* ptr, void* val) {
|
||||
void* atomic_xor_fetch_ptr(void* ptr, int64_t val) {
|
||||
#ifdef WINDOWS
|
||||
return interlocked_xor_fetch_ptr((void* volatile*)(ptr), (void*)(val));
|
||||
#elif defined(_TD_NINGSI_60)
|
||||
|
|
@ -1037,7 +1036,7 @@ int64_t atomic_fetch_xor_64(int64_t volatile* ptr, int64_t val) {
|
|||
#endif
|
||||
}
|
||||
|
||||
void* atomic_fetch_xor_ptr(void* ptr, void* val) {
|
||||
void* atomic_fetch_xor_ptr(void* ptr, int64_t val) {
|
||||
#ifdef WINDOWS
|
||||
return interlocked_fetch_xor_ptr((void* volatile*)(ptr), (void*)(val));
|
||||
#elif defined(_TD_NINGSI_60)
|
||||
|
|
|
|||
|
|
@ -39,7 +39,7 @@ enum {
|
|||
WRDE_SYNTAX /* Shell syntax error. */
|
||||
};
|
||||
|
||||
int wordexp(char *words, wordexp_t *pwordexp, int flags) {
|
||||
int32_t wordexp(char *words, wordexp_t *pwordexp, int32_t flags) {
|
||||
pwordexp->we_offs = 0;
|
||||
pwordexp->we_wordc = 1;
|
||||
pwordexp->we_wordv[0] = pwordexp->wordPos;
|
||||
|
|
@ -197,14 +197,10 @@ int32_t taosMulMkDir(const char *dirname) {
|
|||
}
|
||||
}
|
||||
|
||||
if (code < 0 && errno == EEXIST) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return code;
|
||||
}
|
||||
|
||||
int32_t taosMulModeMkDir(const char *dirname, int mode, bool checkAccess) {
|
||||
int32_t taosMulModeMkDir(const char *dirname, int32_t mode, bool checkAccess) {
|
||||
if (dirname == NULL || strlen(dirname) >= TDDIRMAXLEN) {
|
||||
terrno = TSDB_CODE_INVALID_PARA;
|
||||
return terrno;
|
||||
|
|
@ -326,7 +322,7 @@ void taosRemoveOldFiles(const char *dirname, int32_t keepDays) {
|
|||
int32_t days = (int32_t)(TABS(sec - fileSec) / 86400 + 1);
|
||||
if (days > keepDays) {
|
||||
TAOS_UNUSED(taosRemoveFile(filename));
|
||||
uInfo("file:%s is removed, days:%d keepDays:%d, sed:%" PRId64, filename, days, keepDays, fileSec);
|
||||
// printf("file:%s is removed, days:%d keepDays:%d, sed:%" PRId64, filename, days, keepDays, fileSec);
|
||||
} else {
|
||||
// printf("file:%s won't be removed, days:%d keepDays:%d", filename, days, keepDays);
|
||||
}
|
||||
|
|
@ -340,7 +336,9 @@ void taosRemoveOldFiles(const char *dirname, int32_t keepDays) {
|
|||
int32_t taosExpandDir(const char *dirname, char *outname, int32_t maxlen) {
|
||||
OS_PARAM_CHECK(dirname);
|
||||
OS_PARAM_CHECK(outname);
|
||||
wordexp_t full_path;
|
||||
if (dirname[0] == 0) return 0;
|
||||
|
||||
wordexp_t full_path = {0};
|
||||
int32_t code = wordexp(dirname, &full_path, 0);
|
||||
switch (code) {
|
||||
case 0:
|
||||
|
|
@ -357,13 +355,12 @@ int32_t taosExpandDir(const char *dirname, char *outname, int32_t maxlen) {
|
|||
}
|
||||
|
||||
wordfree(&full_path);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int32_t taosRealPath(char *dirname, char *realPath, int32_t maxlen) {
|
||||
OS_PARAM_CHECK(dirname);
|
||||
OS_PARAM_CHECK(realPath);
|
||||
|
||||
char tmp[PATH_MAX] = {0};
|
||||
#ifdef WINDOWS
|
||||
if (_fullpath(tmp, dirname, maxlen) != NULL) {
|
||||
|
|
@ -377,12 +374,14 @@ int32_t taosRealPath(char *dirname, char *realPath, int32_t maxlen) {
|
|||
tstrncpy(realPath, tmp, maxlen);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
terrno = TAOS_SYSTEM_ERROR(errno);
|
||||
|
||||
} else {
|
||||
terrno = TSDB_CODE_OUT_OF_MEMORY;
|
||||
return terrno;
|
||||
}
|
||||
} else {
|
||||
terrno = TAOS_SYSTEM_ERROR(errno);
|
||||
return terrno;
|
||||
}
|
||||
}
|
||||
|
||||
bool taosIsDir(const char *dirname) {
|
||||
|
|
@ -454,7 +453,7 @@ TdDirPtr taosOpenDir(const char *dirname) {
|
|||
}
|
||||
|
||||
#ifdef WINDOWS
|
||||
char szFind[MAX_PATH]; //这是要找的
|
||||
char szFind[MAX_PATH]; // 这是要找的
|
||||
HANDLE hFind;
|
||||
|
||||
TdDirPtr pDir = taosMemoryMalloc(sizeof(TdDir));
|
||||
|
|
@ -462,7 +461,7 @@ TdDirPtr taosOpenDir(const char *dirname) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
snprintf(szFind, sizeof(szFind), "%s%s", dirname, "\\*.*"); //利用通配符找这个目录下的所以文件，包括目录
|
||||
snprintf(szFind, sizeof(szFind), "%s%s", dirname, "\\*.*"); // 利用通配符找这个目录下的所以文件，包括目录
|
||||
|
||||
pDir->hFind = FindFirstFile(szFind, &(pDir->dirEntry.findFileData));
|
||||
if (INVALID_HANDLE_VALUE == pDir->hFind) {
|
||||
|
|
@ -585,14 +584,14 @@ void taosGetCwd(char *buf, int32_t len) {
|
|||
#endif
|
||||
}
|
||||
|
||||
int taosGetDirSize(const char *path, int64_t *size) {
|
||||
int32_t code;
|
||||
int32_t taosGetDirSize(const char *path, int64_t *size) {
|
||||
int32_t code = 0;
|
||||
char fullPath[PATH_MAX + 100] = {0};
|
||||
|
||||
TdDirPtr pDir = taosOpenDir(path);
|
||||
if (pDir == NULL) {
|
||||
return code = terrno;
|
||||
}
|
||||
int32_t nBytes = 0;
|
||||
char fullPath[1024] = {0};
|
||||
|
||||
int64_t totalSize = 0;
|
||||
TdDirEntryPtr de = NULL;
|
||||
|
|
@ -601,31 +600,23 @@ int taosGetDirSize(const char *path, int64_t *size) {
|
|||
if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0) {
|
||||
continue;
|
||||
}
|
||||
nBytes = snprintf(fullPath, sizeof(fullPath), "%s%s%s", path, TD_DIRSEP, name);
|
||||
if (nBytes <= 0 || nBytes >= sizeof(fullPath)) {
|
||||
TAOS_UNUSED(taosCloseDir(&pDir));
|
||||
return TSDB_CODE_OUT_OF_RANGE;
|
||||
}
|
||||
(void)snprintf(fullPath, sizeof(fullPath), "%s%s%s", path, TD_DIRSEP, name);
|
||||
|
||||
int64_t subSize = 0;
|
||||
if (taosIsDir(fullPath)) {
|
||||
code = taosGetDirSize(fullPath, &subSize);
|
||||
if (code != 0) {
|
||||
TAOS_UNUSED(taosCloseDir(&pDir));
|
||||
return code;
|
||||
}
|
||||
} else {
|
||||
code = taosStatFile(fullPath, &subSize, NULL, NULL);
|
||||
if (code != 0) {
|
||||
TAOS_UNUSED(taosCloseDir(&pDir));
|
||||
return code;
|
||||
}
|
||||
}
|
||||
|
||||
if (code != 0) goto _OVER;
|
||||
|
||||
totalSize += subSize;
|
||||
fullPath[0] = 0;
|
||||
}
|
||||
|
||||
_OVER:
|
||||
*size = totalSize;
|
||||
TAOS_UNUSED(taosCloseDir(&pDir));
|
||||
return 0;
|
||||
return code;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -233,15 +233,19 @@ int32_t taosBlockSIGPIPE() {
|
|||
}
|
||||
|
||||
int32_t taosGetIpv4FromFqdn(const char *fqdn, uint32_t *ip) {
|
||||
int32_t code = 0;
|
||||
OS_PARAM_CHECK(fqdn);
|
||||
OS_PARAM_CHECK(ip);
|
||||
int64_t limitMs = 1000;
|
||||
int64_t st = taosGetTimestampMs(), cost = 0;
|
||||
#ifdef WINDOWS
|
||||
// Initialize Winsock
|
||||
WSADATA wsaData;
|
||||
int iResult;
|
||||
iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
|
||||
if (iResult != 0) {
|
||||
return TAOS_SYSTEM_WINSOCKET_ERROR(WSAGetLastError());
|
||||
code = TAOS_SYSTEM_WINSOCKET_ERROR(WSAGetLastError());
|
||||
goto _err;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
@ -260,12 +264,12 @@ int32_t taosGetIpv4FromFqdn(const char *fqdn, uint32_t *ip) {
|
|||
inRetry = true;
|
||||
continue;
|
||||
} else if (EAI_SYSTEM == ret) {
|
||||
terrno = TAOS_SYSTEM_ERROR(errno);
|
||||
return terrno;
|
||||
code = TAOS_SYSTEM_ERROR(errno);
|
||||
goto _err;
|
||||
}
|
||||
|
||||
terrno = TAOS_SYSTEM_ERROR(errno);
|
||||
return terrno;
|
||||
code = TAOS_SYSTEM_ERROR(errno);
|
||||
goto _err;
|
||||
}
|
||||
|
||||
struct sockaddr *sa = result->ai_addr;
|
||||
|
|
@ -275,8 +279,7 @@ int32_t taosGetIpv4FromFqdn(const char *fqdn, uint32_t *ip) {
|
|||
*ip = ia.s_addr;
|
||||
|
||||
freeaddrinfo(result);
|
||||
|
||||
return 0;
|
||||
goto _err;
|
||||
}
|
||||
#else
|
||||
struct addrinfo hints = {0};
|
||||
|
|
@ -292,7 +295,7 @@ int32_t taosGetIpv4FromFqdn(const char *fqdn, uint32_t *ip) {
|
|||
struct in_addr ia = si->sin_addr;
|
||||
*ip = ia.s_addr;
|
||||
freeaddrinfo(result);
|
||||
return 0;
|
||||
goto _err;
|
||||
} else {
|
||||
#ifdef EAI_SYSTEM
|
||||
if (ret == EAI_SYSTEM) {
|
||||
|
|
@ -305,9 +308,16 @@ int32_t taosGetIpv4FromFqdn(const char *fqdn, uint32_t *ip) {
|
|||
#endif
|
||||
|
||||
*ip = 0xFFFFFFFF;
|
||||
return TSDB_CODE_RPC_FQDN_ERROR;
|
||||
code = TSDB_CODE_RPC_FQDN_ERROR;
|
||||
goto _err;
|
||||
}
|
||||
#endif
|
||||
_err:
|
||||
cost = taosGetTimestampMs() - st;
|
||||
if (cost >= limitMs) {
|
||||
uWarn("get ip from fqdn:%s, cost:%" PRId64 "ms", fqdn, cost);
|
||||
}
|
||||
return code;
|
||||
}
|
||||
|
||||
int32_t taosGetFqdn(char *fqdn) {
|
||||
|
|
|
|||
|
|
@ -71,6 +71,9 @@ add_test(
|
|||
COMMAND osTimeTests
|
||||
)
|
||||
|
||||
|
||||
if(TD_LINUX)
|
||||
|
||||
add_executable(osAtomicTests "osAtomicTests.cpp")
|
||||
target_link_libraries(osAtomicTests os util gtest_main)
|
||||
add_test(
|
||||
|
|
@ -78,6 +81,22 @@ add_test(
|
|||
COMMAND osAtomicTests
|
||||
)
|
||||
|
||||
add_executable(osDirTests "osDirTests.cpp")
|
||||
target_link_libraries(osDirTests os util gtest_main)
|
||||
add_test(
|
||||
NAME osDirTests
|
||||
COMMAND osDirTests
|
||||
)
|
||||
|
||||
add_executable(osEnvTests "osEnvTests.cpp")
|
||||
target_link_libraries(osEnvTests os util gtest_main)
|
||||
add_test(
|
||||
NAME osEnvTests
|
||||
COMMAND osEnvTests
|
||||
)
|
||||
|
||||
endif()
|
||||
|
||||
add_executable(osSemaphoreTests "osSemaphoreTests.cpp")
|
||||
target_link_libraries(osSemaphoreTests os util gtest_main)
|
||||
add_test(
|
||||
|
|
|
|||
|
|
@ -29,87 +29,434 @@
|
|||
#include "os.h"
|
||||
#include "tlog.h"
|
||||
|
||||
TEST(osAtomicTests, Exchange16) {
|
||||
int16_t value = 123;
|
||||
int16_t new_value = 456;
|
||||
int16_t result = atomic_exchange_16(&value, new_value);
|
||||
EXPECT_EQ(result, 123);
|
||||
EXPECT_EQ(value, 456);
|
||||
TEST(osAtomicTests, atomic_load) {
|
||||
int8_t result8 = 0, value8 = 8;
|
||||
int16_t result16 = 0, value16 = 16;
|
||||
int32_t result32 = 0, value32 = 32;
|
||||
int64_t result64 = 0, value64 = 64;
|
||||
void* resultp = &result64;
|
||||
void* valuep = &value64;
|
||||
|
||||
result8 = atomic_load_8(&value8);
|
||||
result16 = atomic_load_16(&value16);
|
||||
result32 = atomic_load_32(&value32);
|
||||
result64 = atomic_load_64(&value64);
|
||||
resultp = atomic_load_ptr(&valuep);
|
||||
|
||||
EXPECT_EQ(result8, 8);
|
||||
EXPECT_EQ(result16, 16);
|
||||
EXPECT_EQ(result32, 32);
|
||||
EXPECT_EQ(result64, 64);
|
||||
EXPECT_EQ(resultp, &value64);
|
||||
EXPECT_EQ(value8, 8);
|
||||
EXPECT_EQ(value16, 16);
|
||||
EXPECT_EQ(value32, 32);
|
||||
EXPECT_EQ(value64, 64);
|
||||
EXPECT_EQ(valuep, &value64);
|
||||
}
|
||||
|
||||
TEST(osAtomicTests, Exchange32) {
|
||||
int32_t value = 123;
|
||||
int32_t new_value = 456;
|
||||
int32_t result = atomic_exchange_32(&value, new_value);
|
||||
EXPECT_EQ(result, 123);
|
||||
EXPECT_EQ(value, 456);
|
||||
TEST(osAtomicTests, atomic_store) {
|
||||
int8_t result8 = 0, value8 = 8;
|
||||
int16_t result16 = 0, value16 = 16;
|
||||
int32_t result32 = 0, value32 = 32;
|
||||
int64_t result64 = 0, value64 = 64;
|
||||
double resultd = 0, valued = 64;
|
||||
void* resultp = &result64;
|
||||
void* valuep = &value64;
|
||||
|
||||
atomic_store_8(&result8, value8);
|
||||
atomic_store_16(&result16, value16);
|
||||
atomic_store_32(&result32, value32);
|
||||
atomic_store_64(&result64, value64);
|
||||
atomic_store_double(&resultd, valued);
|
||||
atomic_store_ptr(&resultp, valuep);
|
||||
|
||||
EXPECT_EQ(result8, 8);
|
||||
EXPECT_EQ(result16, 16);
|
||||
EXPECT_EQ(result32, 32);
|
||||
EXPECT_EQ(result64, 64);
|
||||
EXPECT_DOUBLE_EQ(resultd, 64);
|
||||
EXPECT_EQ(resultp, &value64);
|
||||
}
|
||||
|
||||
TEST(osAtomicTests, Exchange64) {
|
||||
int64_t value = 123;
|
||||
int64_t new_value = 456;
|
||||
int64_t result = atomic_exchange_64(&value, new_value);
|
||||
EXPECT_EQ(result, 123);
|
||||
EXPECT_EQ(value, 456);
|
||||
TEST(osAtomicTests, atomic_exchange) {
|
||||
int8_t result8 = 0, value8 = 8, newval8 = 18;
|
||||
int16_t result16 = 0, value16 = 16, newval16 = 116;
|
||||
int32_t result32 = 0, value32 = 32, newval32 = 132;
|
||||
int64_t result64 = 0, value64 = 64, newval64 = 164;
|
||||
double resultd = 0, valued = 64, newvald = 164;
|
||||
void* valuep = &value64;
|
||||
void* newvalp = &newval64;
|
||||
void* resultp = &result64;
|
||||
|
||||
result8 = atomic_exchange_8(&value8, newval8);
|
||||
result16 = atomic_exchange_16(&value16, newval16);
|
||||
result32 = atomic_exchange_32(&value32, newval32);
|
||||
result64 = atomic_exchange_64(&value64, newval64);
|
||||
resultd = atomic_exchange_double(&valued, newvald);
|
||||
resultp = atomic_exchange_ptr(&valuep, newvalp);
|
||||
|
||||
EXPECT_EQ(value8, 18);
|
||||
EXPECT_EQ(value16, 116);
|
||||
EXPECT_EQ(value32, 132);
|
||||
EXPECT_EQ(value64, 164);
|
||||
EXPECT_DOUBLE_EQ(valued, 164);
|
||||
EXPECT_EQ(valuep, &newval64);
|
||||
|
||||
EXPECT_EQ(result8, 8);
|
||||
EXPECT_EQ(result16, 16);
|
||||
EXPECT_EQ(result32, 32);
|
||||
EXPECT_EQ(result64, 64);
|
||||
EXPECT_DOUBLE_EQ(resultd, 64);
|
||||
EXPECT_EQ(resultp, &value64);
|
||||
}
|
||||
|
||||
TEST(osAtomicTests, ExchangePtr) {
|
||||
int value1 = 123;
|
||||
int value2 = 456;
|
||||
int* ptr = &value1;
|
||||
int* result = (int*)atomic_exchange_ptr(&ptr, &value2);
|
||||
EXPECT_EQ(result, &value1);
|
||||
EXPECT_EQ(*ptr, 456);
|
||||
TEST(osAtomicTests, atomic_val_compare_exchange) {
|
||||
int8_t result8 = 0, value8 = 8, oldval8 = 8, newval8 = 18;
|
||||
int16_t result16 = 0, value16 = 16, oldval16 = 16, newval16 = 116;
|
||||
int32_t result32 = 0, value32 = 32, oldval32 = 32, newval32 = 132;
|
||||
int64_t result64 = 0, value64 = 64, oldval64 = 64, newval64 = 164;
|
||||
void* resultp = NULL;
|
||||
void* valuep = &value64;
|
||||
void* oldvalp = &value64;
|
||||
void* newvalp = &newval64;
|
||||
|
||||
result8 = atomic_val_compare_exchange_8(&value8, oldval8, newval8);
|
||||
result16 = atomic_val_compare_exchange_16(&value16, oldval16, newval16);
|
||||
result32 = atomic_val_compare_exchange_32(&value32, oldval32, newval32);
|
||||
result64 = atomic_val_compare_exchange_64(&value64, oldval64, newval64);
|
||||
resultp = atomic_val_compare_exchange_ptr(&valuep, oldvalp, newvalp);
|
||||
|
||||
EXPECT_EQ(result8, 8);
|
||||
EXPECT_EQ(value8, 18);
|
||||
EXPECT_EQ(result16, 16);
|
||||
EXPECT_EQ(value16, 116);
|
||||
EXPECT_EQ(result32, 32);
|
||||
EXPECT_EQ(value32, 132);
|
||||
EXPECT_EQ(result64, 64);
|
||||
EXPECT_EQ(value64, 164);
|
||||
EXPECT_EQ(resultp, &value64);
|
||||
EXPECT_EQ(valuep, &newval64);
|
||||
|
||||
oldval8 = 9;
|
||||
oldval16 = 99;
|
||||
oldval32 = 999;
|
||||
oldval64 = 9999;
|
||||
oldvalp = NULL;
|
||||
|
||||
result8 = atomic_val_compare_exchange_8(&value8, oldval8, newval8);
|
||||
result16 = atomic_val_compare_exchange_16(&value16, oldval16, newval16);
|
||||
result32 = atomic_val_compare_exchange_32(&value32, oldval32, newval32);
|
||||
result64 = atomic_val_compare_exchange_64(&value64, oldval64, newval64);
|
||||
resultp = atomic_val_compare_exchange_ptr(&valuep, oldvalp, newvalp);
|
||||
|
||||
EXPECT_EQ(result8, 18);
|
||||
EXPECT_EQ(value8, 18);
|
||||
EXPECT_EQ(result16, 116);
|
||||
EXPECT_EQ(value16, 116);
|
||||
EXPECT_EQ(result32, 132);
|
||||
EXPECT_EQ(value32, 132);
|
||||
EXPECT_EQ(result64, 164);
|
||||
EXPECT_EQ(value64, 164);
|
||||
EXPECT_EQ(resultp, &newval64);
|
||||
EXPECT_EQ(valuep, &newval64);
|
||||
}
|
||||
|
||||
TEST(osAtomicTests, ValCompareExchange8) {
|
||||
int8_t value = 12;
|
||||
int8_t oldval = 12;
|
||||
int8_t newval = 45;
|
||||
int8_t result = atomic_val_compare_exchange_8(&value, oldval, newval);
|
||||
EXPECT_EQ(result, 12);
|
||||
EXPECT_EQ(value, 45);
|
||||
TEST(osAtomicTests, atomic_add_fetch) {
|
||||
int8_t result8 = 0, value8 = 8;
|
||||
int16_t result16 = 0, value16 = 16;
|
||||
int32_t result32 = 0, value32 = 32;
|
||||
int64_t result64 = 0, value64 = 64;
|
||||
|
||||
oldval = 78;
|
||||
result = atomic_val_compare_exchange_8(&value, oldval, newval);
|
||||
EXPECT_EQ(result, 45);
|
||||
EXPECT_EQ(value, 45);
|
||||
int64_t valuex = 128;
|
||||
int64_t* valuep = &valuex;
|
||||
int64_t resultx = 0;
|
||||
|
||||
result8 = atomic_add_fetch_8(&value8, 10);
|
||||
result16 = atomic_add_fetch_16(&value16, 10);
|
||||
result32 = atomic_add_fetch_32(&value32, 10);
|
||||
result64 = atomic_add_fetch_64(&value64, 10);
|
||||
resultx = (int64_t)atomic_add_fetch_ptr(valuep, 10);
|
||||
|
||||
EXPECT_EQ(result8, 18);
|
||||
EXPECT_EQ(value8, 18);
|
||||
EXPECT_EQ(result16, 26);
|
||||
EXPECT_EQ(value16, 26);
|
||||
EXPECT_EQ(result32, 42);
|
||||
EXPECT_EQ(value32, 42);
|
||||
EXPECT_EQ(result64, 74);
|
||||
EXPECT_EQ(value64, 74);
|
||||
EXPECT_EQ(resultx, 138);
|
||||
EXPECT_EQ(*valuep, 138);
|
||||
EXPECT_EQ(valuex, 138);
|
||||
}
|
||||
|
||||
TEST(osAtomicTests, ValCompareExchange16) {
|
||||
int16_t value = 123;
|
||||
int16_t oldval = 123;
|
||||
int16_t newval = 456;
|
||||
int16_t result = atomic_val_compare_exchange_16(&value, oldval, newval);
|
||||
EXPECT_EQ(result, 123);
|
||||
EXPECT_EQ(value, 456);
|
||||
TEST(osAtomicTests, atomic_fetch_add) {
|
||||
int8_t result8 = 0, value8 = 8;
|
||||
int16_t result16 = 0, value16 = 16;
|
||||
int32_t result32 = 0, value32 = 32;
|
||||
int64_t result64 = 0, value64 = 64;
|
||||
double resultd = 0, valued = 64;
|
||||
|
||||
oldval = 789;
|
||||
result = atomic_val_compare_exchange_16(&value, oldval, newval);
|
||||
EXPECT_EQ(result, 456);
|
||||
EXPECT_EQ(value, 456);
|
||||
int64_t valuex = 128;
|
||||
int64_t* valuep = &valuex;
|
||||
int64_t resultx = 0;
|
||||
|
||||
result8 = atomic_fetch_add_8(&value8, 10);
|
||||
result16 = atomic_fetch_add_16(&value16, 10);
|
||||
result32 = atomic_fetch_add_32(&value32, 10);
|
||||
result64 = atomic_fetch_add_64(&value64, 10);
|
||||
resultd = atomic_fetch_add_double(&valued, 10);
|
||||
resultx = (int64_t)atomic_fetch_add_ptr(valuep, 10);
|
||||
|
||||
EXPECT_EQ(result8, 8);
|
||||
EXPECT_EQ(value8, 18);
|
||||
EXPECT_EQ(result16, 16);
|
||||
EXPECT_EQ(value16, 26);
|
||||
EXPECT_EQ(result32, 32);
|
||||
EXPECT_EQ(value32, 42);
|
||||
EXPECT_EQ(result64, 64);
|
||||
EXPECT_EQ(value64, 74);
|
||||
EXPECT_DOUBLE_EQ(resultd, 64);
|
||||
EXPECT_DOUBLE_EQ(valued, 74);
|
||||
EXPECT_EQ(resultx, 128);
|
||||
EXPECT_EQ(*valuep, 138);
|
||||
EXPECT_EQ(valuex, 138);
|
||||
}
|
||||
|
||||
TEST(osAtomicTests, TestAtomicExchange8) {
|
||||
volatile int8_t value = 42;
|
||||
int8_t new_value = 100;
|
||||
int8_t old_value = atomic_exchange_8(&value, new_value);
|
||||
EXPECT_EQ(old_value, 42);
|
||||
EXPECT_EQ(value, new_value);
|
||||
TEST(osAtomicTests, atomic_sub_fetch) {
|
||||
int8_t result8 = 0, value8 = 8;
|
||||
int16_t result16 = 0, value16 = 16;
|
||||
int32_t result32 = 0, value32 = 32;
|
||||
int64_t result64 = 0, value64 = 64;
|
||||
|
||||
int64_t valuex = 128;
|
||||
int64_t* valuep = &valuex;
|
||||
int64_t resultx = 0;
|
||||
|
||||
result8 = atomic_sub_fetch_8(&value8, 10);
|
||||
result16 = atomic_sub_fetch_16(&value16, 10);
|
||||
result32 = atomic_sub_fetch_32(&value32, 10);
|
||||
result64 = atomic_sub_fetch_64(&value64, 10);
|
||||
resultx = (int64_t)atomic_sub_fetch_ptr(valuep, 10);
|
||||
|
||||
EXPECT_EQ(result8, -2);
|
||||
EXPECT_EQ(value8, -2);
|
||||
EXPECT_EQ(result16, 6);
|
||||
EXPECT_EQ(value16, 6);
|
||||
EXPECT_EQ(result32, 22);
|
||||
EXPECT_EQ(value32, 22);
|
||||
EXPECT_EQ(result64, 54);
|
||||
EXPECT_EQ(value64, 54);
|
||||
EXPECT_EQ(resultx, 118);
|
||||
EXPECT_EQ(*valuep, 118);
|
||||
EXPECT_EQ(valuex, 118);
|
||||
}
|
||||
|
||||
TEST(osAtomicTests, TestAtomicAddFetch16) {
|
||||
volatile int16_t value = 42;
|
||||
int16_t increment = 10;
|
||||
int16_t new_value = atomic_add_fetch_16(&value, increment);
|
||||
EXPECT_EQ(new_value, 52);
|
||||
EXPECT_EQ(value, 52);
|
||||
TEST(osAtomicTests, atomic_fetch_sub) {
|
||||
int8_t result8 = 0, value8 = 8;
|
||||
int16_t result16 = 0, value16 = 16;
|
||||
int32_t result32 = 0, value32 = 32;
|
||||
int64_t result64 = 0, value64 = 64;
|
||||
double resultd = 0, valued = 64;
|
||||
|
||||
int64_t valuex = 128;
|
||||
int64_t* valuep = &valuex;
|
||||
int64_t resultx = 0;
|
||||
|
||||
result8 = atomic_fetch_sub_8(&value8, 10);
|
||||
result16 = atomic_fetch_sub_16(&value16, 10);
|
||||
result32 = atomic_fetch_sub_32(&value32, 10);
|
||||
result64 = atomic_fetch_sub_64(&value64, 10);
|
||||
resultd = atomic_fetch_sub_double(&valued, 10);
|
||||
resultx = (int64_t)atomic_fetch_sub_ptr(valuep, 10);
|
||||
|
||||
EXPECT_EQ(result8, 8);
|
||||
EXPECT_EQ(value8, -2);
|
||||
EXPECT_EQ(result16, 16);
|
||||
EXPECT_EQ(value16, 6);
|
||||
EXPECT_EQ(result32, 32);
|
||||
EXPECT_EQ(value32, 22);
|
||||
EXPECT_EQ(result64, 64);
|
||||
EXPECT_EQ(value64, 54);
|
||||
EXPECT_DOUBLE_EQ(resultd, 64);
|
||||
EXPECT_DOUBLE_EQ(valued, 54);
|
||||
EXPECT_EQ(resultx, 128);
|
||||
EXPECT_EQ(*valuep, 118);
|
||||
EXPECT_EQ(valuex, 118);
|
||||
}
|
||||
|
||||
//TEST(osAtomicTests, AddFetchPtr) {
|
||||
// uintptr_t val = 0;
|
||||
// uintptr_t* ptr = &val;
|
||||
// uintptr_t ret = atomic_add_fetch_ptr(ptr, 10);
|
||||
// EXPECT_EQ(ret, 10);
|
||||
// EXPECT_EQ(val, 10);
|
||||
//}
|
||||
TEST(osAtomicTests, atomic_and_fetch) {
|
||||
int8_t result8 = 0, value8 = 3;
|
||||
int16_t result16 = 0, value16 = 3;
|
||||
int32_t result32 = 0, value32 = 3;
|
||||
int64_t result64 = 0, value64 = 3;
|
||||
|
||||
int64_t valuex = 3;
|
||||
int64_t* valuep = &valuex;
|
||||
int64_t resultx = 0;
|
||||
|
||||
result8 = atomic_and_fetch_8(&value8, 5);
|
||||
result16 = atomic_and_fetch_16(&value16, 5);
|
||||
result32 = atomic_and_fetch_32(&value32, 5);
|
||||
result64 = atomic_and_fetch_64(&value64, 5);
|
||||
resultx = (int64_t)atomic_and_fetch_ptr(valuep, 5);
|
||||
|
||||
EXPECT_EQ(result8, 1);
|
||||
EXPECT_EQ(value8, 1);
|
||||
EXPECT_EQ(result16, 1);
|
||||
EXPECT_EQ(value16, 1);
|
||||
EXPECT_EQ(result32, 1);
|
||||
EXPECT_EQ(value32, 1);
|
||||
EXPECT_EQ(result64, 1);
|
||||
EXPECT_EQ(value64, 1);
|
||||
EXPECT_EQ(resultx, 1);
|
||||
EXPECT_EQ(*valuep, 1);
|
||||
EXPECT_EQ(valuex, 1);
|
||||
}
|
||||
|
||||
TEST(osAtomicTests, atomic_fetch_and) {
|
||||
int8_t result8 = 0, value8 = 3;
|
||||
int16_t result16 = 0, value16 = 3;
|
||||
int32_t result32 = 0, value32 = 3;
|
||||
int64_t result64 = 0, value64 = 3;
|
||||
|
||||
int64_t valuex = 3;
|
||||
int64_t* valuep = &valuex;
|
||||
int64_t resultx = 0;
|
||||
|
||||
result8 = atomic_fetch_and_8(&value8, 5);
|
||||
result16 = atomic_fetch_and_16(&value16, 5);
|
||||
result32 = atomic_fetch_and_32(&value32, 5);
|
||||
result64 = atomic_fetch_and_64(&value64, 5);
|
||||
resultx = (int64_t)atomic_fetch_and_ptr(valuep, 5);
|
||||
|
||||
EXPECT_EQ(result8, 3);
|
||||
EXPECT_EQ(value8, 1);
|
||||
EXPECT_EQ(result16, 3);
|
||||
EXPECT_EQ(value16, 1);
|
||||
EXPECT_EQ(result32, 3);
|
||||
EXPECT_EQ(value32, 1);
|
||||
EXPECT_EQ(result64, 3);
|
||||
EXPECT_EQ(value64, 1);
|
||||
EXPECT_EQ(resultx, 3);
|
||||
EXPECT_EQ(*valuep, 1);
|
||||
EXPECT_EQ(valuex, 1);
|
||||
}
|
||||
|
||||
TEST(osAtomicTests, atomic_or_fetch) {
|
||||
int8_t result8 = 0, value8 = 3;
|
||||
int16_t result16 = 0, value16 = 3;
|
||||
int32_t result32 = 0, value32 = 3;
|
||||
int64_t result64 = 0, value64 = 3;
|
||||
|
||||
int64_t valuex = 3;
|
||||
int64_t* valuep = &valuex;
|
||||
int64_t resultx = 0;
|
||||
|
||||
result8 = atomic_or_fetch_8(&value8, 5);
|
||||
result16 = atomic_or_fetch_16(&value16, 5);
|
||||
result32 = atomic_or_fetch_32(&value32, 5);
|
||||
result64 = atomic_or_fetch_64(&value64, 5);
|
||||
resultx = (int64_t)atomic_or_fetch_ptr(valuep, 5);
|
||||
|
||||
EXPECT_EQ(result8, 7);
|
||||
EXPECT_EQ(value8, 7);
|
||||
EXPECT_EQ(result16, 7);
|
||||
EXPECT_EQ(value16, 7);
|
||||
EXPECT_EQ(result32, 7);
|
||||
EXPECT_EQ(value32, 7);
|
||||
EXPECT_EQ(result64, 7);
|
||||
EXPECT_EQ(value64, 7);
|
||||
EXPECT_EQ(resultx, 7);
|
||||
EXPECT_EQ(*valuep, 7);
|
||||
EXPECT_EQ(valuex, 7);
|
||||
}
|
||||
|
||||
TEST(osAtomicTests, atomic_fetch_or) {
|
||||
int8_t result8 = 0, value8 = 3;
|
||||
int16_t result16 = 0, value16 = 3;
|
||||
int32_t result32 = 0, value32 = 3;
|
||||
int64_t result64 = 0, value64 = 3;
|
||||
|
||||
int64_t valuex = 3;
|
||||
int64_t* valuep = &valuex;
|
||||
int64_t resultx = 0;
|
||||
|
||||
result8 = atomic_fetch_or_8(&value8, 5);
|
||||
result16 = atomic_fetch_or_16(&value16, 5);
|
||||
result32 = atomic_fetch_or_32(&value32, 5);
|
||||
result64 = atomic_fetch_or_64(&value64, 5);
|
||||
resultx = (int64_t)atomic_fetch_or_ptr(valuep, 5);
|
||||
|
||||
EXPECT_EQ(result8, 3);
|
||||
EXPECT_EQ(value8, 7);
|
||||
EXPECT_EQ(result16, 3);
|
||||
EXPECT_EQ(value16, 7);
|
||||
EXPECT_EQ(result32, 3);
|
||||
EXPECT_EQ(value32, 7);
|
||||
EXPECT_EQ(result64, 3);
|
||||
EXPECT_EQ(value64, 7);
|
||||
EXPECT_EQ(resultx, 3);
|
||||
EXPECT_EQ(*valuep, 7);
|
||||
EXPECT_EQ(valuex, 7);
|
||||
}
|
||||
|
||||
|
||||
TEST(osAtomicTests, atomic_xor_fetch) {
|
||||
int8_t result8 = 0, value8 = 3;
|
||||
int16_t result16 = 0, value16 = 3;
|
||||
int32_t result32 = 0, value32 = 3;
|
||||
int64_t result64 = 0, value64 = 3;
|
||||
|
||||
int64_t valuex = 3;
|
||||
int64_t* valuep = &valuex;
|
||||
int64_t resultx = 0;
|
||||
|
||||
result8 = atomic_xor_fetch_8(&value8, 5);
|
||||
result16 = atomic_xor_fetch_16(&value16, 5);
|
||||
result32 = atomic_xor_fetch_32(&value32, 5);
|
||||
result64 = atomic_xor_fetch_64(&value64, 5);
|
||||
resultx = (int64_t)atomic_xor_fetch_ptr(valuep, 5);
|
||||
|
||||
EXPECT_EQ(result8, 6);
|
||||
EXPECT_EQ(value8, 6);
|
||||
EXPECT_EQ(result16, 6);
|
||||
EXPECT_EQ(value16, 6);
|
||||
EXPECT_EQ(result32, 6);
|
||||
EXPECT_EQ(value32, 6);
|
||||
EXPECT_EQ(result64, 6);
|
||||
EXPECT_EQ(value64, 6);
|
||||
EXPECT_EQ(resultx, 6);
|
||||
EXPECT_EQ(*valuep, 6);
|
||||
EXPECT_EQ(valuex, 6);
|
||||
}
|
||||
|
||||
TEST(osAtomicTests, atomic_fetch_xor) {
|
||||
int8_t result8 = 0, value8 = 3;
|
||||
int16_t result16 = 0, value16 = 3;
|
||||
int32_t result32 = 0, value32 = 3;
|
||||
int64_t result64 = 0, value64 = 3;
|
||||
|
||||
int64_t valuex = 3;
|
||||
int64_t* valuep = &valuex;
|
||||
int64_t resultx = 0;
|
||||
|
||||
result8 = atomic_fetch_xor_8(&value8, 5);
|
||||
result16 = atomic_fetch_xor_16(&value16, 5);
|
||||
result32 = atomic_fetch_xor_32(&value32, 5);
|
||||
result64 = atomic_fetch_xor_64(&value64, 5);
|
||||
resultx = (int64_t)atomic_fetch_xor_ptr(valuep, 5);
|
||||
|
||||
EXPECT_EQ(result8, 3);
|
||||
EXPECT_EQ(value8, 6);
|
||||
EXPECT_EQ(result16, 3);
|
||||
EXPECT_EQ(value16, 6);
|
||||
EXPECT_EQ(result32, 3);
|
||||
EXPECT_EQ(value32, 6);
|
||||
EXPECT_EQ(result64, 3);
|
||||
EXPECT_EQ(value64, 6);
|
||||
EXPECT_EQ(resultx, 3);
|
||||
EXPECT_EQ(*valuep, 6);
|
||||
EXPECT_EQ(valuex, 6);
|
||||
}
|
||||
|
|
@ -0,0 +1,464 @@
|
|||
/*
|
||||
* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
|
||||
*
|
||||
* This program is free software: you can use, redistribute, and/or modify
|
||||
* it under the terms of the GNU Affero General Public License, version 3
|
||||
* or later ("AGPL"), as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE.
|
||||
*
|
||||
* You should have received a copy of the GNU Affero General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
#include <iostream>
|
||||
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wwrite-strings"
|
||||
#pragma GCC diagnostic ignored "-Wunused-function"
|
||||
#pragma GCC diagnostic ignored "-Wunused-variable"
|
||||
#pragma GCC diagnostic ignored "-Wsign-compare"
|
||||
#pragma GCC diagnostic ignored "-Wsign-compare"
|
||||
#pragma GCC diagnostic ignored "-Wformat"
|
||||
#pragma GCC diagnostic ignored "-Wint-to-pointer-cast"
|
||||
#pragma GCC diagnostic ignored "-Wpointer-arith"
|
||||
|
||||
#include "os.h"
|
||||
#include "tlog.h"
|
||||
|
||||
TEST(osDirTests, taosRemoveDir) {
|
||||
int32_t ret = 0;
|
||||
|
||||
const char* testDir = "/tmp/tdengine-test-dir";
|
||||
if (taosDirExist(testDir)) {
|
||||
taosRemoveDir(testDir);
|
||||
}
|
||||
|
||||
taosRemoveDir(testDir);
|
||||
|
||||
ret = taosMkDir(testDir);
|
||||
EXPECT_EQ(ret, 0);
|
||||
|
||||
const char* testFile = "/tmp/tdengine-test-dir/test-file";
|
||||
TdFilePtr testFilePtr = taosCreateFile(testFile, TD_FILE_CREATE);
|
||||
EXPECT_NE(testFilePtr, nullptr);
|
||||
ret = taosCloseFile(&testFilePtr);
|
||||
EXPECT_EQ(ret, 0);
|
||||
|
||||
const char* testDir2 = "/tmp/tdengine-test-dir/test-dir2";
|
||||
ret = taosMkDir(testDir2);
|
||||
EXPECT_EQ(ret, 0);
|
||||
|
||||
const char* testFile2 = "/tmp/tdengine-test-dir/test-dir2/test-file2";
|
||||
TdFilePtr testFilePtr2 = taosCreateFile(testFile2, TD_FILE_CREATE);
|
||||
EXPECT_NE(testFilePtr2, nullptr);
|
||||
ret = taosCloseFile(&testFilePtr2);
|
||||
EXPECT_EQ(ret, 0);
|
||||
|
||||
taosRemoveDir(testDir);
|
||||
|
||||
bool exist = taosDirExist(testDir);
|
||||
EXPECT_EQ(exist, false);
|
||||
|
||||
taosRemoveDir("/tmp/tdengine-test-dir");
|
||||
}
|
||||
|
||||
TEST(osDirTests, taosDirExist) {
|
||||
const char* dir1 = NULL;
|
||||
bool exist = taosDirExist(dir1);
|
||||
EXPECT_EQ(exist, false);
|
||||
|
||||
char dir2[2048] = {0};
|
||||
for (int32_t i = 0; i < 2047; ++i) {
|
||||
dir2[i] = 1;
|
||||
}
|
||||
exist = taosDirExist(dir2);
|
||||
EXPECT_EQ(exist, false);
|
||||
|
||||
taosRemoveDir("/tmp/tdengine-test-dir");
|
||||
}
|
||||
|
||||
TEST(osDirTests, taosMulMkDir) {
|
||||
int32_t ret = 0;
|
||||
|
||||
const char* dir1 = NULL;
|
||||
ret = taosMulMkDir(dir1);
|
||||
EXPECT_EQ(ret, -1);
|
||||
|
||||
char dir2[2048] = {0};
|
||||
for (int32_t i = 0; i < 2047; ++i) {
|
||||
dir2[i] = '1';
|
||||
}
|
||||
ret = taosMulMkDir(dir2);
|
||||
EXPECT_EQ(ret, -1);
|
||||
|
||||
const char* dir3 = "/tmp/tdengine-test-dir/1/2/3/4";
|
||||
taosRemoveDir(dir3);
|
||||
ret = taosMulMkDir(dir3);
|
||||
EXPECT_EQ(ret, 0);
|
||||
taosRemoveDir(dir3);
|
||||
|
||||
const char* dir4 = "./tdengine-test-dir/1/2/3/4";
|
||||
taosRemoveDir(dir4);
|
||||
ret = taosMulMkDir(dir4);
|
||||
EXPECT_EQ(ret, 0);
|
||||
taosRemoveDir(dir4);
|
||||
|
||||
const char* dir5 = "tdengine-test-dir/1/2/3/4";
|
||||
taosRemoveDir(dir5);
|
||||
ret = taosMulMkDir(dir5);
|
||||
EXPECT_EQ(ret, 0);
|
||||
ret = taosMulMkDir(dir5);
|
||||
EXPECT_EQ(ret, 0);
|
||||
taosRemoveDir(dir5);
|
||||
|
||||
const char* testFile = "/tmp/tdengine-test-dir/test-file";
|
||||
TdFilePtr testFilePtr = taosCreateFile(testFile, TD_FILE_CREATE);
|
||||
EXPECT_NE(testFilePtr, nullptr);
|
||||
ret = taosCloseFile(&testFilePtr);
|
||||
EXPECT_EQ(ret, 0);
|
||||
char dir6[2048] = {0};
|
||||
strcpy(dir6, "/tmp/tdengine-test-dir/test-file/1/2/3/4");
|
||||
ret = taosMulMkDir(dir6);
|
||||
EXPECT_NE(ret, 0);
|
||||
|
||||
taosRemoveDir("/tmp/tdengine-test-dir");
|
||||
}
|
||||
|
||||
TEST(osDirTests, taosMulModeMkDir) {
|
||||
int32_t ret = 0;
|
||||
|
||||
const char* dir1 = NULL;
|
||||
ret = taosMulModeMkDir(dir1, 777, true);
|
||||
EXPECT_NE(ret, 0);
|
||||
|
||||
char dir2[2048] = {0};
|
||||
for (int32_t i = 0; i < 2047; ++i) {
|
||||
dir2[i] = '1';
|
||||
}
|
||||
ret = taosMulModeMkDir(dir2, 777, true);
|
||||
EXPECT_NE(ret, 0);
|
||||
|
||||
const char* dir3 = "/tmp/tdengine-test-dir/1/2/3/4";
|
||||
taosRemoveDir(dir3);
|
||||
ret = taosMulMkDir(dir3);
|
||||
EXPECT_EQ(ret, 0);
|
||||
ret = taosMulModeMkDir(dir3, 777, true);
|
||||
EXPECT_EQ(ret, 0);
|
||||
ret = taosMulModeMkDir(dir3, 777, false);
|
||||
EXPECT_EQ(ret, 0);
|
||||
ret = taosMulModeMkDir(dir3, 999, true);
|
||||
EXPECT_EQ(ret, 0);
|
||||
ret = taosMulModeMkDir(dir3, 999, false);
|
||||
EXPECT_EQ(ret, 0);
|
||||
taosRemoveDir(dir3);
|
||||
|
||||
const char* dir4 = "./tdengine-test-dir/1/2/3/4";
|
||||
taosRemoveDir(dir4);
|
||||
ret = taosMulModeMkDir(dir4, 777, true);
|
||||
EXPECT_EQ(ret, 0);
|
||||
ret = taosMulModeMkDir(dir4, 777, false);
|
||||
EXPECT_EQ(ret, 0);
|
||||
taosRemoveDir(dir4);
|
||||
|
||||
const char* dir5 = "tdengine-test-dir/1/2/3/4";
|
||||
taosRemoveDir(dir5);
|
||||
ret = taosMulModeMkDir(dir5, 777, true);
|
||||
EXPECT_EQ(ret, 0);
|
||||
ret = taosMulModeMkDir(dir5, 777, false);
|
||||
EXPECT_EQ(ret, 0);
|
||||
ret = taosMulModeMkDir(dir5, 777, true);
|
||||
EXPECT_EQ(ret, 0);
|
||||
ret = taosMulModeMkDir(dir5, 777, false);
|
||||
EXPECT_EQ(ret, 0);
|
||||
taosRemoveDir(dir5);
|
||||
|
||||
const char* testFile = "/tmp/tdengine-test-dir/test-file";
|
||||
TdFilePtr testFilePtr = taosCreateFile(testFile, TD_FILE_CREATE);
|
||||
EXPECT_NE(testFilePtr, nullptr);
|
||||
ret = taosCloseFile(&testFilePtr);
|
||||
EXPECT_EQ(ret, 0);
|
||||
char dir6[2048] = {0};
|
||||
strcpy(dir6, "/tmp/tdengine-test-dir/test-file/1/2/3/4");
|
||||
ret = taosMulModeMkDir(dir6, 777, true);
|
||||
EXPECT_NE(ret, 0);
|
||||
|
||||
const char* dir7 = "tdengine-test-dir/1/2/3/5";
|
||||
taosRemoveDir(dir7);
|
||||
ret = taosMulModeMkDir(dir7, 999, true);
|
||||
EXPECT_EQ(ret, 0);
|
||||
ret = taosMulModeMkDir(dir7, 999, false);
|
||||
EXPECT_EQ(ret, 0);
|
||||
|
||||
taosRemoveDir("/tmp/tdengine-test-dir");
|
||||
}
|
||||
|
||||
TEST(osDirTests, taosRemoveOldFiles) {
|
||||
int32_t ret = 0;
|
||||
const char* testDir = "/tmp/tdengine-test-dir";
|
||||
if (taosDirExist(testDir)) {
|
||||
taosRemoveDir(testDir);
|
||||
}
|
||||
taosRemoveDir(testDir);
|
||||
ret = taosMkDir(testDir);
|
||||
EXPECT_EQ(ret, 0);
|
||||
|
||||
const char* testFile = "/tmp/tdengine-test-dir/test-file";
|
||||
TdFilePtr testFilePtr = taosCreateFile(testFile, TD_FILE_CREATE);
|
||||
EXPECT_NE(testFilePtr, nullptr);
|
||||
ret = taosCloseFile(&testFilePtr);
|
||||
EXPECT_EQ(ret, 0);
|
||||
|
||||
taosRemoveOldFiles(testFile, 10);
|
||||
|
||||
const char* testDir2 = "/tmp/tdengine-test-dir/test-dir2";
|
||||
ret = taosMkDir(testDir2);
|
||||
EXPECT_EQ(ret, 0);
|
||||
|
||||
const char* testFile3 = "/tmp/tdengine-test-dir/log.1433726073.gz";
|
||||
TdFilePtr testFilePtr3 = taosCreateFile(testFile3, TD_FILE_CREATE);
|
||||
EXPECT_NE(testFilePtr3, nullptr);
|
||||
ret = taosCloseFile(&testFilePtr3);
|
||||
EXPECT_EQ(ret, 0);
|
||||
|
||||
const char* testFile4 = "/tmp/tdengine-test-dir/log.80.gz";
|
||||
TdFilePtr testFilePtr4 = taosCreateFile(testFile4, TD_FILE_CREATE);
|
||||
EXPECT_NE(testFilePtr4, nullptr);
|
||||
ret = taosCloseFile(&testFilePtr4);
|
||||
EXPECT_EQ(ret, 0);
|
||||
|
||||
char testFile5[1024];
|
||||
snprintf(testFile5, 1024, "/tmp/tdengine-test-dir/log.%d.gz", taosGetTimestampSec());
|
||||
TdFilePtr testFilePtr5 = taosCreateFile(testFile5, TD_FILE_CREATE);
|
||||
EXPECT_NE(testFilePtr5, nullptr);
|
||||
ret = taosCloseFile(&testFilePtr5);
|
||||
EXPECT_EQ(ret, 0);
|
||||
|
||||
const char* testFile6 = "/tmp/tdengine-test-dir/log.1433726073.gz";
|
||||
TdFilePtr testFilePtr6 = taosCreateFile(testFile6, TD_FILE_CREATE);
|
||||
EXPECT_NE(testFilePtr6, nullptr);
|
||||
ret = taosCloseFile(&testFilePtr6);
|
||||
EXPECT_EQ(ret, 0);
|
||||
|
||||
taosRemoveOldFiles(testDir, 10);
|
||||
|
||||
bool exist = taosDirExist(testDir);
|
||||
EXPECT_EQ(exist, true);
|
||||
|
||||
taosRemoveDir("/tmp/tdengine-test-dir");
|
||||
}
|
||||
|
||||
TEST(osDirTests, taosExpandDir) {
|
||||
int32_t ret = 0;
|
||||
const char* testDir = "/tmp/tdengine-test-dir";
|
||||
ret = taosMkDir(testDir);
|
||||
EXPECT_EQ(ret, 0);
|
||||
|
||||
char fullpath[1024] = {0};
|
||||
ret = taosExpandDir(testDir, NULL, 1024);
|
||||
EXPECT_NE(ret, 0);
|
||||
ret = taosExpandDir(NULL, fullpath, 1024);
|
||||
EXPECT_NE(ret, 0);
|
||||
ret = taosExpandDir(testDir, fullpath, 1024);
|
||||
EXPECT_EQ(ret, 0);
|
||||
|
||||
ret = taosExpandDir("/x123", fullpath, 1024);
|
||||
EXPECT_EQ(ret, 0);
|
||||
|
||||
ret = taosExpandDir("", fullpath, 1024);
|
||||
EXPECT_EQ(ret, 0);
|
||||
|
||||
char dir2[2048] = {0};
|
||||
for (int32_t i = 0; i < 2047; ++i) {
|
||||
dir2[i] = '1';
|
||||
}
|
||||
ret = taosExpandDir(dir2, fullpath, 1024);
|
||||
EXPECT_EQ(ret, 0);
|
||||
|
||||
taosRemoveDir("/tmp/tdengine-test-dir");
|
||||
}
|
||||
|
||||
TEST(osDirTests, taosRealPath) {
|
||||
int32_t ret = 0;
|
||||
char testDir[PATH_MAX * 2] = "/tmp/tdengine-test-dir";
|
||||
ret = taosMkDir(testDir);
|
||||
EXPECT_EQ(ret, 0);
|
||||
|
||||
char fullpath[PATH_MAX * 2] = {0};
|
||||
|
||||
ret = taosRealPath(testDir, NULL, PATH_MAX * 2);
|
||||
EXPECT_EQ(ret, 0);
|
||||
|
||||
ret = taosRealPath(NULL, fullpath, PATH_MAX * 2);
|
||||
EXPECT_NE(ret, 0);
|
||||
|
||||
ret = taosRealPath(testDir, fullpath, PATH_MAX * 2);
|
||||
EXPECT_EQ(ret, 0);
|
||||
|
||||
ret = taosRealPath(testDir, fullpath, 12);
|
||||
EXPECT_NE(ret, 0);
|
||||
|
||||
ret = taosRealPath("/c/d", fullpath, 1024);
|
||||
EXPECT_NE(ret, 0);
|
||||
|
||||
taosRemoveDir("/tmp/tdengine-test-dir");
|
||||
}
|
||||
|
||||
TEST(osDirTests, taosIsDir) {
|
||||
bool ret = taosIsDir("/c/d");
|
||||
EXPECT_EQ(ret, false);
|
||||
}
|
||||
|
||||
TEST(osDirTests, taosDirName) {
|
||||
char* ret = taosDirName(NULL);
|
||||
EXPECT_EQ(ret, nullptr);
|
||||
|
||||
char name1[24] = "xyz";
|
||||
ret = taosDirName(name1);
|
||||
EXPECT_NE(ret, nullptr);
|
||||
EXPECT_EQ(name1[0], 0);
|
||||
|
||||
char name2[24] = "/root/xyz";
|
||||
ret = taosDirName(name2);
|
||||
EXPECT_NE(ret, nullptr);
|
||||
EXPECT_STREQ(ret, "/root");
|
||||
}
|
||||
|
||||
TEST(osDirTests, taosDirEntryBaseName) {
|
||||
char* ret = taosDirEntryBaseName(NULL);
|
||||
EXPECT_EQ(ret, nullptr);
|
||||
|
||||
char name1[12] = "/";
|
||||
ret = taosDirEntryBaseName(name1);
|
||||
EXPECT_STREQ(ret, "/");
|
||||
|
||||
char name2[12] = "/root/";
|
||||
ret = taosDirEntryBaseName(name2);
|
||||
EXPECT_STREQ(ret, "root");
|
||||
|
||||
char name3[12] = "/root";
|
||||
ret = taosDirEntryBaseName(name3);
|
||||
EXPECT_STREQ(ret, "root");
|
||||
|
||||
char name4[12] = "root";
|
||||
ret = taosDirEntryBaseName(name4);
|
||||
EXPECT_STREQ(ret, "root");
|
||||
}
|
||||
|
||||
TEST(osDirTests, taosOpenDir) {
|
||||
TdDirPtr ret = taosOpenDir(NULL);
|
||||
EXPECT_EQ(ret, nullptr);
|
||||
}
|
||||
|
||||
TEST(osDirTests, taosReadDir) {
|
||||
TdDirEntryPtr rddir = taosReadDir(NULL);
|
||||
EXPECT_EQ(rddir, nullptr);
|
||||
|
||||
int32_t ret = 0;
|
||||
const char* testDir = "/tmp/tdengine-test-dir";
|
||||
ret = taosMkDir(testDir);
|
||||
EXPECT_EQ(ret, 0);
|
||||
|
||||
const char* testFile = "/tmp/tdengine-test-dir/test-file";
|
||||
TdFilePtr testFilePtr = taosCreateFile(testFile, TD_FILE_CREATE);
|
||||
EXPECT_NE(testFilePtr, nullptr);
|
||||
ret = taosCloseFile(&testFilePtr);
|
||||
EXPECT_EQ(ret, 0);
|
||||
|
||||
TdDirPtr dir = taosOpenDir(testFile);
|
||||
EXPECT_EQ(dir, nullptr);
|
||||
|
||||
const char* testDir2 = "/tmp/tdengine-test-dir/test-dir2";
|
||||
ret = taosMkDir(testDir2);
|
||||
EXPECT_EQ(ret, 0);
|
||||
|
||||
const char* testFile2 = "/tmp/tdengine-test-dir/test-dir2/test-file2";
|
||||
TdFilePtr testFilePtr2 = taosCreateFile(testFile2, TD_FILE_CREATE);
|
||||
EXPECT_NE(testFilePtr2, nullptr);
|
||||
ret = taosCloseFile(&testFilePtr2);
|
||||
EXPECT_EQ(ret, 0);
|
||||
|
||||
dir = taosOpenDir(testFile);
|
||||
EXPECT_EQ(dir, nullptr);
|
||||
|
||||
rddir = taosReadDir(dir);
|
||||
EXPECT_EQ(rddir, nullptr);
|
||||
|
||||
dir = taosOpenDir(testDir);
|
||||
EXPECT_NE(dir, nullptr);
|
||||
|
||||
rddir = taosReadDir(dir);
|
||||
EXPECT_NE(rddir, nullptr);
|
||||
|
||||
bool entry = taosDirEntryIsDir(NULL);
|
||||
EXPECT_EQ(entry, false);
|
||||
|
||||
char* entryname = taosGetDirEntryName(NULL);
|
||||
EXPECT_EQ(entryname, nullptr);
|
||||
|
||||
entryname = taosGetDirEntryName(rddir);
|
||||
EXPECT_NE(entryname, nullptr);
|
||||
|
||||
int32_t code = taosCloseDir(NULL);
|
||||
EXPECT_NE(code, 0);
|
||||
|
||||
code = taosCloseDir(&dir);
|
||||
EXPECT_EQ(code, 0);
|
||||
|
||||
taosRemoveDir("/tmp/tdengine-test-dir");
|
||||
}
|
||||
|
||||
TEST(osDirTests, taosGetDirSize) {
|
||||
TdDirEntryPtr rddir = taosReadDir(NULL);
|
||||
EXPECT_EQ(rddir, nullptr);
|
||||
|
||||
int32_t ret = 0;
|
||||
const char* testDir = "/tmp/tdengine-test-dir";
|
||||
ret = taosMkDir(testDir);
|
||||
EXPECT_EQ(ret, 0);
|
||||
|
||||
const char* testFile = "/tmp/tdengine-test-dir/test-file";
|
||||
TdFilePtr testFilePtr = taosCreateFile(testFile, TD_FILE_CREATE);
|
||||
EXPECT_NE(testFilePtr, nullptr);
|
||||
ret = taosCloseFile(&testFilePtr);
|
||||
EXPECT_EQ(ret, 0);
|
||||
|
||||
TdDirPtr dir = taosOpenDir(testFile);
|
||||
EXPECT_EQ(dir, nullptr);
|
||||
|
||||
const char* testDir2 = "/tmp/tdengine-test-dir/test-dir2";
|
||||
ret = taosMkDir(testDir2);
|
||||
EXPECT_EQ(ret, 0);
|
||||
|
||||
const char* testFile2 = "/tmp/tdengine-test-dir/test-dir2/test-file2";
|
||||
TdFilePtr testFilePtr2 = taosCreateFile(testFile2, TD_FILE_CREATE);
|
||||
EXPECT_NE(testFilePtr2, nullptr);
|
||||
ret = taosCloseFile(&testFilePtr2);
|
||||
EXPECT_EQ(ret, 0);
|
||||
|
||||
int64_t size = -1;
|
||||
ret = taosGetDirSize(testFile, &size);
|
||||
EXPECT_NE(ret, 0);
|
||||
|
||||
ret = taosGetDirSize(testDir, &size);
|
||||
EXPECT_EQ(ret, 0);
|
||||
|
||||
taosRemoveDir("/tmp/tdengine-test-dir");
|
||||
|
||||
taosRemoveDir("./tdengine-test-dir/1/2/3/5");
|
||||
taosRemoveDir("./tdengine-test-dir/1/2/3/4");
|
||||
taosRemoveDir("./tdengine-test-dir/1/2/3");
|
||||
taosRemoveDir("./tdengine-test-dir/1/2");
|
||||
taosRemoveDir("./tdengine-test-dir/1");
|
||||
taosRemoveDir("./tdengine-test-dir/");
|
||||
taosRemoveDir("tdengine-test-dir/1/2/3/5");
|
||||
taosRemoveDir("tdengine-test-dir/1/2/3/4");
|
||||
taosRemoveDir("tdengine-test-dir/1/2/3");
|
||||
taosRemoveDir("tdengine-test-dir/1/2");
|
||||
taosRemoveDir("tdengine-test-dir/1");
|
||||
taosRemoveDir("tdengine-test-dir/");
|
||||
taosRemoveDir("tdengine-test-dir/");
|
||||
}
|
||||
|
|
@ -0,0 +1,93 @@
|
|||
/*
|
||||
* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
|
||||
*
|
||||
* This program is free software: you can use, redistribute, and/or modify
|
||||
* it under the terms of the GNU Affero General Public License, version 3
|
||||
* or later ("AGPL"), as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE.
|
||||
*
|
||||
* You should have received a copy of the GNU Affero General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
#include <iostream>
|
||||
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wwrite-strings"
|
||||
#pragma GCC diagnostic ignored "-Wunused-function"
|
||||
#pragma GCC diagnostic ignored "-Wunused-variable"
|
||||
#pragma GCC diagnostic ignored "-Wsign-compare"
|
||||
#pragma GCC diagnostic ignored "-Wsign-compare"
|
||||
#pragma GCC diagnostic ignored "-Wformat"
|
||||
#pragma GCC diagnostic ignored "-Wint-to-pointer-cast"
|
||||
#pragma GCC diagnostic ignored "-Wpointer-arith"
|
||||
|
||||
#include "os.h"
|
||||
#include "tlog.h"
|
||||
|
||||
TEST(osEnvTests, osDefaultInit) {
|
||||
int32_t ret = 0;
|
||||
|
||||
strcpy(tsTimezoneStr, "");
|
||||
strcpy(tsTempDir, "");
|
||||
tsNumOfCores = 0;
|
||||
ret = osDefaultInit();
|
||||
EXPECT_EQ(ret, 0);
|
||||
|
||||
strcpy(tsTempDir, "/tmp");
|
||||
ret = osDefaultInit();
|
||||
EXPECT_EQ(ret, 0);
|
||||
|
||||
osCleanup();
|
||||
}
|
||||
|
||||
TEST(osEnvTests, osUpdate) {
|
||||
int32_t ret = 0;
|
||||
|
||||
strcpy(tsLogDir, "");
|
||||
strcpy(tsDataDir, "");
|
||||
strcpy(tsTempDir, "");
|
||||
|
||||
ret = osUpdate();
|
||||
EXPECT_EQ(ret, 0);
|
||||
}
|
||||
|
||||
TEST(osEnvTests, osSufficient) {
|
||||
bool ret = 0;
|
||||
|
||||
tsLogSpace.size.avail = 10000;
|
||||
tsDataSpace.size.avail = 10000;
|
||||
tsTempSpace.size.avail = 10000;
|
||||
tsLogSpace.reserved = 2000;
|
||||
tsDataSpace.reserved = 2000;
|
||||
tsDataSpace.reserved = 2000;
|
||||
|
||||
ret = osLogSpaceAvailable();
|
||||
EXPECT_EQ(ret, true);
|
||||
|
||||
ret = osTempSpaceAvailable();
|
||||
EXPECT_EQ(ret, true);
|
||||
|
||||
ret = osDataSpaceAvailable();
|
||||
EXPECT_EQ(ret, true);
|
||||
|
||||
ret = osLogSpaceSufficient();
|
||||
EXPECT_EQ(ret, true);
|
||||
|
||||
ret = osDataSpaceSufficient();
|
||||
EXPECT_EQ(ret, true);
|
||||
|
||||
ret = osTempSpaceSufficient();
|
||||
EXPECT_EQ(ret, true);
|
||||
|
||||
osSetSystemLocale(NULL, NULL);
|
||||
osSetSystemLocale(NULL, NULL);
|
||||
osSetSystemLocale("1", "2");
|
||||
|
||||
osSetProcPath(1, NULL);
|
||||
osSetProcPath(0, (char **)&ret);
|
||||
}
|
||||
|
|
@ -33,6 +33,13 @@ ENDIF()
|
|||
INCLUDE_DIRECTORIES(${TD_SOURCE_DIR}/src/util/inc)
|
||||
INCLUDE_DIRECTORIES(${TD_SOURCE_DIR}/include/common)
|
||||
|
||||
add_executable(heapTest "heapTest.cpp")
|
||||
target_link_libraries(heapTest os util gtest_main)
|
||||
add_test(
|
||||
NAME heapTest
|
||||
COMMAND heapTest
|
||||
)
|
||||
|
||||
# arrayTest
|
||||
add_executable(arrayTest "arrayTest.cpp")
|
||||
target_link_libraries(arrayTest os util gtest_main)
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ int32_t heapCompare(const HeapNode* a, const HeapNode* b) {
|
|||
return 1;
|
||||
}
|
||||
|
||||
TEST(TD_UTIL_HEAP_TEST, heapTest) {
|
||||
TEST(heapTest, heapTest) {
|
||||
Heap* heap = heapCreate(heapCompare);
|
||||
ASSERT_TRUE(heap != NULL);
|
||||
ASSERT_EQ(0, heapSize(heap));
|
||||
|
|
|
|||
|
|
@ -80,7 +80,7 @@ else
|
|||
fi
|
||||
|
||||
|
||||
mv ${REP_REAL_PATH}/debug ${WORKDIR}/debugSan
|
||||
rm -rf ${REP_REAL_PATH}/debug
|
||||
date
|
||||
|
||||
ret=$?
|
||||
|
|
|
|||
|
|
@ -1082,6 +1082,7 @@
|
|||
,,n,system-test,python3 ./test.py -f 5-taos-tools/taosbenchmark/insertMix.py -N 3
|
||||
,,n,system-test,python3 ./test.py -f 5-taos-tools/taosbenchmark/stt.py -N 3
|
||||
,,n,system-test,python3 ./test.py -f eco-system/meta/database/keep_time_offset.py
|
||||
,,y,system-test,./pytest.sh python3 ./test.py -f eco-system/manager/schema_change.py -N 3 -M 3
|
||||
|
||||
#tsim test
|
||||
,,y,script,./test.sh -f tsim/query/timeline.sim
|
||||
|
|
|
|||
|
|
@ -27,7 +27,6 @@ function runCasesOneByOne () {
|
|||
|| echo -e "${RED}$case failed${NC}" | tee -a $TDENGINE_ALLCI_REPORT
|
||||
end_time=`date +%s`
|
||||
echo execution time of $case was `expr $end_time - $start_time`s. | tee -a $TDENGINE_ALLCI_REPORT
|
||||
if $case failed
|
||||
|
||||
elif [[ "$line" == *"$2"* ]]; then
|
||||
if [[ "$cmd" == *"pytest.sh"* ]]; then
|
||||
|
|
|
|||
|
|
@ -289,6 +289,64 @@ if $data51 != $query1_data51 then
|
|||
goto loop3
|
||||
endi
|
||||
|
||||
print ======step3
|
||||
sql create database test3 vgroups 1;
|
||||
sql use test3;
|
||||
|
||||
sql create stable st(ts timestamp, a int, b int , c int)tags(ta int,tb int,tc int);
|
||||
sql create table t1 using st tags(1,1,1);
|
||||
sql create table t2 using st tags(2,2,2);
|
||||
|
||||
sql create stream streams3 trigger force_window_close IGNORE EXPIRED 1 IGNORE UPDATE 1 into streamt3 as select _wstart, twa(a), ta from st partition by tbname,ta interval(10s);
|
||||
|
||||
run tsim/stream/checkTaskStatus.sim
|
||||
|
||||
sql insert into t1 values(now + 3000a,1,1,1);
|
||||
sql flush database test;
|
||||
sql insert into t1 values(now + 3001a,10,10,10);
|
||||
sql insert into t1 values(now + 13s,50,50,50);
|
||||
|
||||
sleep 1000
|
||||
|
||||
print sql select _wstart, twa(a), ta from st partition by tbname,ta interval(10s) order by 1;
|
||||
sql select _wstart, twa(a), ta from st partition by tbname,ta interval(10s) order by 1;
|
||||
|
||||
$query_data01 = $data01
|
||||
|
||||
print $data00 $data01 $data02 $data03 $data04
|
||||
print $data10 $data11 $data12 $data13 $data14
|
||||
print $data20 $data21 $data22 $data23 $data24
|
||||
print $data30 $data31 $data32 $data33 $data34
|
||||
print $data40 $data41 $data42 $data43 $data44
|
||||
print $data50 $data51 $data52 $data53 $data54
|
||||
|
||||
|
||||
$loop_count = 0
|
||||
loop4:
|
||||
|
||||
sleep 2000
|
||||
|
||||
$loop_count = $loop_count + 1
|
||||
if $loop_count == 20 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
print 2 sql select * from streamt3 order by 1;
|
||||
sql select * from streamt3 order by 1;
|
||||
|
||||
print $data00 $data01 $data02 $data03 $data04
|
||||
print $data10 $data11 $data12 $data13 $data14
|
||||
print $data20 $data21 $data22 $data23 $data24
|
||||
print $data30 $data31 $data32 $data33 $data34
|
||||
print $data40 $data41 $data42 $data43 $data44
|
||||
print $data50 $data51 $data52 $data53 $data54
|
||||
|
||||
if $data01 != $query_data01 then
|
||||
print ======data01======$data01
|
||||
print ====query_data01=$query_data01
|
||||
goto loop4
|
||||
endi
|
||||
|
||||
print end
|
||||
|
||||
system sh/exec.sh -n dnode1 -s stop -x SIGINT
|
||||
|
|
|
|||
|
|
@ -515,6 +515,18 @@ class TDTestCase:
|
|||
tdSql.query(f"select t1 from {dbname}.stb1 where abs(c1+t1)=1")
|
||||
tdSql.checkRows(1)
|
||||
tdSql.checkData(0,0,0)
|
||||
tdSql.query(f"select * from {dbname}.stb1")
|
||||
rows = tdSql.queryRows
|
||||
tdSql.query(f"select t1 from {dbname}.stb1 where abs(c1+t1)=1 or (1<2)")
|
||||
tdSql.checkRows(rows)
|
||||
tdSql.query(f"select t1 from {dbname}.stb1 where abs(c1+t1)=1 and (1<2)")
|
||||
tdSql.checkRows(1)
|
||||
tdSql.checkData(0,0,0)
|
||||
tdSql.query(f"select t1 from {dbname}.stb1 where abs(c1+t1)=1 and (1>2)")
|
||||
tdSql.checkRows(0)
|
||||
tdSql.query(f"select t1 from {dbname}.stb1 where abs(c1+t1)=1 or (1>2)")
|
||||
tdSql.checkRows(1)
|
||||
tdSql.checkData(0,0,0)
|
||||
|
||||
tdSql.query(
|
||||
f"select abs(c1+t1)*t1 from {dbname}.stb1 where abs(c1)/floor(abs(ceil(t1))) ==1")
|
||||
|
|
|
|||
|
|
@ -452,6 +452,73 @@ class TDTestCase:
|
|||
tdSql.query(sql, queryTimes=1)
|
||||
tdSql.checkRows(5)
|
||||
|
||||
def test_TS_5727(self):
|
||||
tdSql.execute(f" use {self.dbname} ")
|
||||
stableName = "test5727"
|
||||
sql = f"CREATE STABLE {self.dbname}.{stableName} (`ts` TIMESTAMP, `WaterConsumption` FLOAT, \
|
||||
`ElecConsumption` INT, `Status` BOOL, `status2` BOOL, `online` BOOL) \
|
||||
TAGS (`ActivationTime` TIMESTAMP, `ProductId` INT, \
|
||||
`ProductMac` VARCHAR(24), `location` INT)"
|
||||
tdSql.execute(sql)
|
||||
|
||||
sql = f'CREATE TABLE {self.dbname}.`d00` USING {self.dbname}.{stableName} \
|
||||
(`ActivationTime`, `ProductId`, `ProductMac`, `location`) \
|
||||
TAGS (1733124710578, 1001, "00:11:22:33:44:55", 100000)'
|
||||
tdSql.execute(sql)
|
||||
sql = f'CREATE TABLE {self.dbname}.`d01` USING {self.dbname}.{stableName} \
|
||||
(`ActivationTime`, `ProductId`, `ProductMac`, `location`) \
|
||||
TAGS (1733124723572, 1002, "00:12:22:33:44:55", 200000)'
|
||||
tdSql.execute(sql)
|
||||
sql = f'CREATE TABLE {self.dbname}.`d02` USING {self.dbname}.{stableName} \
|
||||
(`ActivationTime`, `ProductId`, `ProductMac`, `location`) \
|
||||
TAGS (1733124730908, 1003, "00:11:23:33:44:55", 100000)'
|
||||
tdSql.execute(sql)
|
||||
|
||||
sql = f'insert into {self.dbname}.d00 values(now - 2s, 5, 5, true, true, false);'
|
||||
tdSql.execute(sql)
|
||||
sql = f'insert into {self.dbname}.d01 values(now - 1s, 6, 5, true, true, true);'
|
||||
tdSql.execute(sql)
|
||||
sql = f'insert into {self.dbname}.d02 values(now, 6, 7, true, true, true);'
|
||||
tdSql.execute(sql)
|
||||
|
||||
sql = f'select `location`, tbname from {self.dbname}.{stableName} where ts < now group by tbname order by tbname;'
|
||||
tdSql.query(sql)
|
||||
tdSql.checkRows(3)
|
||||
tdSql.checkData(0, 0, 100000)
|
||||
tdSql.checkData(1, 0, 200000)
|
||||
tdSql.checkData(2, 0, 100000)
|
||||
tdSql.checkData(0, 1, "d00")
|
||||
tdSql.checkData(1, 1, "d01")
|
||||
tdSql.checkData(2, 1, "d02")
|
||||
|
||||
sql = f'select tbname,last(online) as online,location from {self.dbname}.{stableName} where ts < now group by tbname order by tbname;'
|
||||
tdSql.query(sql)
|
||||
tdSql.checkRows(3)
|
||||
tdSql.checkData(0, 0, "d00")
|
||||
tdSql.checkData(1, 0, "d01")
|
||||
tdSql.checkData(2, 0, "d02")
|
||||
tdSql.checkData(0, 1, False)
|
||||
tdSql.checkData(1, 1, True)
|
||||
tdSql.checkData(2, 1, True)
|
||||
tdSql.checkData(0, 2, 100000)
|
||||
tdSql.checkData(1, 2, 200000)
|
||||
tdSql.checkData(2, 2, 100000)
|
||||
|
||||
|
||||
sql = f'select location,tbname,last_row(online) as online from {self.dbname}.{stableName} where ts < now group by tbname order by tbname;'
|
||||
tdSql.query(sql)
|
||||
tdSql.checkRows(3)
|
||||
tdSql.checkData(0, 0, 100000)
|
||||
tdSql.checkData(1, 0, 200000)
|
||||
tdSql.checkData(2, 0, 100000)
|
||||
tdSql.checkData(0, 1, "d00")
|
||||
tdSql.checkData(1, 1, "d01")
|
||||
tdSql.checkData(2, 1, "d02")
|
||||
tdSql.checkData(0, 2, False)
|
||||
tdSql.checkData(1, 2, True)
|
||||
tdSql.checkData(2, 2, True)
|
||||
|
||||
|
||||
def run(self):
|
||||
tdSql.prepare()
|
||||
self.prepare_db()
|
||||
|
|
@ -494,6 +561,8 @@ class TDTestCase:
|
|||
|
||||
self.test_error()
|
||||
|
||||
self.test_TS_5727()
|
||||
|
||||
|
||||
def stop(self):
|
||||
tdSql.close()
|
||||
|
|
|
|||
|
|
@ -64,6 +64,10 @@ class TDTestCase:
|
|||
tdSql.query(f"select tbname , max(c1) from {dbname}.sub_stb_1 where c1 is null group by c1 order by c1 desc ")
|
||||
tdSql.checkRows(1)
|
||||
tdSql.checkData(0,0,"sub_stb_1")
|
||||
tdSql.query(f"select tbname , max(c1) from {dbname}.sub_stb_1 group by c1 order by c1 desc ")
|
||||
rows = tdSql.queryRows
|
||||
tdSql.query(f"select tbname , max(c1) from {dbname}.sub_stb_1 where c1 is null or (1<2) group by c1 order by c1 desc ")
|
||||
tdSql.checkRows(rows)
|
||||
|
||||
tdSql.query(f"select max(c1) ,c2 ,t2,tbname from {dbname}.stb group by abs(c1) order by abs(c1)")
|
||||
tdSql.checkRows(self.row_nums+1)
|
||||
|
|
|
|||
|
|
@ -75,6 +75,25 @@ class TDTestCase:
|
|||
tdSql.checkData(1, 1, 3)
|
||||
tdSql.checkData(2, 1, 9)
|
||||
|
||||
tdSql.query(f"select * from {dbname}.stb_1 order by ts")
|
||||
rows = tdSql.queryRows
|
||||
tdSql.query(f"select * from {dbname}.stb_1 where col1 in (1, 2) or (1<2) order by ts")
|
||||
tdSql.checkRows(rows)
|
||||
|
||||
tdSql.query(f"select * from (select * from {dbname}.stb_1 where col1 in (1, 9, 3) or (1<2) order by ts)")
|
||||
tdSql.checkRows(rows)
|
||||
|
||||
tdSql.query(f"select * from {dbname}.stb_1 where col1 in (1, 2) and (1<2) order by ts")
|
||||
tdSql.checkRows(2)
|
||||
tdSql.checkData(0, 1, 1)
|
||||
tdSql.checkData(1, 1, 2)
|
||||
|
||||
tdSql.query(f"select * from {dbname}.stb_1 where col1 in (1, 9, 3) and (1<2) order by ts")
|
||||
tdSql.checkRows(3)
|
||||
tdSql.checkData(0, 1, 1)
|
||||
tdSql.checkData(1, 1, 3)
|
||||
tdSql.checkData(2, 1, 9)
|
||||
|
||||
tdSql.query(f"select * from {dbname}.stb_1 where col1 in (1, 9, 3, 'xy') order by ts")
|
||||
tdSql.checkRows(3)
|
||||
tdSql.checkData(0, 1, 1)
|
||||
|
|
@ -160,7 +179,7 @@ class TDTestCase:
|
|||
tdSql.prepare()
|
||||
|
||||
self.timeZoneTest()
|
||||
# self.inAndNotinTest()
|
||||
self.inAndNotinTest()
|
||||
|
||||
|
||||
def stop(self):
|
||||
|
|
|
|||
|
|
@ -28,6 +28,10 @@ class TDTestCase:
|
|||
for type_name in stype:
|
||||
tdsql.execute(f"drop table if exists {dbname}.{stbname}")
|
||||
tdsql.execute(f"create table if not exists {dbname}.{stbname} (ts timestamp, v1 {type_name}) tags(t1 {type_name})")
|
||||
|
||||
tdsql.query(f"select t1, * from {dbname}.{stbname} where t1 not in (1, 2) or (1<2) order by t1")
|
||||
tdsql.checkRows(0)
|
||||
|
||||
tdsql.execute(f"insert into {dbname}.sub_1 using {dbname}.{stbname} tags(1) values({self.ts}, 10)")
|
||||
tdsql.execute(f"insert into {dbname}.sub_2 using {dbname}.{stbname} tags(2) values({self.ts + 1000}, 20)")
|
||||
tdsql.execute(f"insert into {dbname}.sub_3 using {dbname}.{stbname} tags(3) values({self.ts + 2000}, 30)")
|
||||
|
|
@ -36,6 +40,11 @@ class TDTestCase:
|
|||
tdsql.query(f"select t1, * from {dbname}.{stbname} where t1 not in (1, 2) order by t1")
|
||||
tdsql.checkRows(1)
|
||||
tdsql.checkData(0, 0, 3)
|
||||
tdsql.query(f"select * from {dbname}.{stbname} where t1 not in (1, 2) or (1<2) order by t1")
|
||||
tdsql.checkRows(3)
|
||||
tdsql.checkData(0, 1, 10)
|
||||
tdsql.checkData(1, 1, 20)
|
||||
tdsql.checkData(2, 1, 30)
|
||||
|
||||
# Test case 2: NOT BETWEEN
|
||||
tdsql.query(f"select * from {dbname}.{stbname} where v1 not between 10 and 20 order by t1")
|
||||
|
|
|
|||
|
|
@ -426,6 +426,15 @@ class TDTestCase:
|
|||
|
||||
tdLog.printNoPrefix("==========step4:after wal, all check again ")
|
||||
self.all_test()
|
||||
self.test_TD_33137()
|
||||
|
||||
def test_TD_33137(self):
|
||||
sql = "select 'asd' union all select 'asdasd'"
|
||||
tdSql.query(sql, queryTimes=1)
|
||||
tdSql.checkRows(2)
|
||||
sql = "select db_name `TABLE_CAT`, '' `TABLE_SCHEM`, stable_name `TABLE_NAME`, 'TABLE' `TABLE_TYPE`, table_comment `REMARKS` from information_schema.ins_stables union all select db_name `TABLE_CAT`, '' `TABLE_SCHEM`, table_name `TABLE_NAME`, case when `type`='SYSTEM_TABLE' then 'TABLE' when `type`='NORMAL_TABLE' then 'TABLE' when `type`='CHILD_TABLE' then 'TABLE' else 'UNKNOWN' end `TABLE_TYPE`, table_comment `REMARKS` from information_schema.ins_tables union all select db_name `TABLE_CAT`, '' `TABLE_SCHEM`, view_name `TABLE_NAME`, 'VIEW' `TABLE_TYPE`, NULL `REMARKS` from information_schema.ins_views"
|
||||
tdSql.query(sql, queryTimes=1)
|
||||
tdSql.checkRows(48)
|
||||
|
||||
def stop(self):
|
||||
tdSql.close()
|
||||
|
|
|
|||
|
|
@ -133,8 +133,17 @@ class TDTestCase:
|
|||
if len(tags) < 10:
|
||||
return
|
||||
|
||||
sel_cols = random.sample(columns, random.randint(2,int(len(columns)/10)))
|
||||
sel_tags = random.sample(tags, random.randint(1,int(len(tags)/10)))
|
||||
# cmax
|
||||
cmax = int(len(columns)/10)
|
||||
if cmax <=2 :
|
||||
cmax = 3
|
||||
sel_cols = random.sample(columns, random.randint(2, cmax))
|
||||
|
||||
# tmax
|
||||
tmax = int(len(tags)/10)
|
||||
if tmax <=1 :
|
||||
tmax = 2
|
||||
sel_tags = random.sample(tags, random.randint(1, tmax))
|
||||
|
||||
field_cols = ",".join(sel_cols)
|
||||
field_tags = ",".join(sel_tags)
|
||||
|
|
@ -217,18 +226,43 @@ class TDTestCase:
|
|||
#time.sleep(0.3)
|
||||
|
||||
|
||||
# create db and stb
|
||||
def create(self, db, stb, cols, tags):
|
||||
# create db
|
||||
sql = f"create database {db} ;"
|
||||
tdSql.execute(sql)
|
||||
|
||||
# switch db
|
||||
tdSql.execute(f"use {db};")
|
||||
|
||||
# cols
|
||||
sql1 = ""
|
||||
for k, v in cols.items():
|
||||
sql1 += f",{k} {v}"
|
||||
# tags
|
||||
sql2 = ""
|
||||
for k, v in tags.items():
|
||||
if sql2 == "":
|
||||
sql2 = f"{k} {v}"
|
||||
else:
|
||||
sql2 += f",{k} {v}"
|
||||
|
||||
# create stb
|
||||
sql = f"create table {db}.{stb}(ts timestamp {sql1}) tags({sql2})"
|
||||
tdSql.execute(sql)
|
||||
|
||||
# run
|
||||
def run(self):
|
||||
# seed
|
||||
random.seed(int(time.time()))
|
||||
self.dbname = "schema_change"
|
||||
|
||||
# switch db
|
||||
tdSql.execute(f"use {self.dbname};")
|
||||
# create db
|
||||
self.create(self.dbname, "meters", self.column_dict, self.tag_dict)
|
||||
|
||||
|
||||
# change meters
|
||||
self.change_schema(1000000)
|
||||
|
||||
self.change_schema(1000)
|
||||
|
||||
|
||||
def stop(self):
|
||||
|
|
|
|||
Loading…
Reference in New Issue