xxq250
/
homework-jianmu
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Merge pull request #30022 from taosdata/merge/mainto3.0 

merge: from main to 3.0 branch
This commit is contained in:
Simon Guan 2025-03-05 19:44:38 +08:00 committed by GitHub
parent 393f49141f 34120a38c5
commit 9023f2f505
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
92 changed files with 2004 additions and 1948 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
docs/zh/03-intro.md
View File

@ -16,7 +16,7 @@ TDengine OSS 是一个开源的高性能时序数据库，与其他时序数据
在 TDengine OSS 的基础上，TDengine Enterprise 提供了增强的辅助功能，包括数据的备份恢复、异地容灾、多级存储、视图、权限控制、安全加密、IP 白名单、支持 MQTT、OPC-UA、OPC-DA、PI、Wonderware、Kafka 等各种数据源。这些功能为企业提供了更为全面、安全、可靠和高效的时序数据管理解决方案。更多的细节请看 [TDengine Enterprise](https://www.taosdata.com/tdengine-pro)。
此外，TDengine Cloud 作为一种全托管的云服务，存储与计算分离，分开计费，为企业提供了企业级的工具和服务，彻底解决了运维难题，尤其适合中小规模的用户使用。更多的细节请看[TDengine 云服务](https://cloud.taosdata.com/?utm_source=menu&utm_medium=webcn)
此外，TDengine Cloud 作为一种全托管的云服务，存储与计算分离，分开计费，为企业提供了企业级的工具和服务，彻底解决了运维难题，尤其适合中小规模的用户使用。更多的细节请看 [TDengine 云服务](https://cloud.taosdata.com/?utm_source=menu&utm_medium=webcn)。
## TDengine 主要功能与特性

27
docs/zh/07-develop/04-schemaless.md
View File

@ -17,7 +17,7 @@ import TabItem from "@theme/TabItem";
## 无模式写入行协议
TDengine 的无模式写入行协议兼容 InfluxDB 的行协议、OpenTSDB 的 telnet 行协议和 OpenTSDB 的 JSON 格式协议。InfluxDB、OpenTSDB 的标准写入协议请参考各自的官方文档。
TDengine 的无模式写入行协议兼容 InfluxDB 的行协议、OpenTSDB 的 TELNET 行协议和 OpenTSDB 的 JSON 格式协议。InfluxDB、OpenTSDB 的标准写入协议请参考各自的官方文档。
下面首先以 InfluxDB 的行协议为基础，介绍 TDengine 扩展的协议内容。该协议允许用户采用更加精细的方式控制（超级表）模式。采用一个字符串来表达一个数据行，可以向写入 API 中一次传入多行字符串来实现多个数据行的批量写入，其格式约定如下。
@ -70,10 +70,9 @@ tag_set 中的所有的数据自动转化为 nchar 数据类型，并不需要
| 5 | i32/u32 | Int/UInt | 4 |
| 6 | i64/i/u64/u | BigInt/BigInt/UBigInt/UBigInt | 8 |
- t, T, true, True, TRUE, f, F, false, False 将直接作为 BOOL 型来处理。
- t、T、true、True、TRUE、f、F、false、False 将直接作为 BOOL 型来处理。
例如如下数据行表示：向名为 st 的超级表下的 t1 标签为 "3"（NCHAR）、t2 标签为 "4"（NCHAR）、t3
标签为 "t3"（NCHAR）的数据子表，写入 c1 列为 3（BIGINT）、c2 列为 false（BOOL）、c3
例如如下数据行表示：向名为 st 的超级表下的 t1 标签为 "3"（NCHAR）、t2 标签为 "4"（NCHAR）、t3 标签为 "t3"（NCHAR）的数据子表，写入 c1 列为 3（BIGINT）、c2 列为 false（BOOL）、c3
列为 "passit"（BINARY）、c4 列为 4（DOUBLE）、主键时间戳为 1626006833639000000 的一行数据。
```json
@ -94,24 +93,22 @@ TDengine 提供数据写入的幂等性保证，即您可以反复调用 API 进
"measurement,tag_key1=tag_value1,tag_key2=tag_value2"
```
- 需要注意的是，这里的 tag_key1, tag_key2 并不是用户输入的标签的原始顺序，而是使用了标签名称按照字符串升序排列后的结果。所以，tag_key1 并不是在行协议中输入的第一个标签。
排列完成以后计算该字符串的 MD5 散列值 "md5_val"。然后将计算的结果与字符串组合生成表名：“t_md5_val”。其中的 “t_” 是固定的前缀，每个通过该映射关系自动生成的表都具有该前缀。
- 需要注意的是，这里的 tag_key1、tag_key2 并不是用户输入的标签的原始顺序，而是使用了标签名称按照字符串升序排列后的结果。所以，tag_key1 并不是在行协议中输入的第一个标签。
排列完成以后计算该字符串的 MD5 散列值 "md5_val"。然后将计算的结果与字符串组合生成表名："t_md5_val"。其中的 "t_" 是固定的前缀，每个通过该映射关系自动生成的表都具有该前缀。
- 如果不想用自动生成的表名，有两种指定子表名的方式(第一种优先级更高)。
1. 通过在taos.cfg里配置 smlAutoChildTableNameDelimiter 参数来指定（`@ # 空格 回车 换行 制表符`除外)。
1. 举例如下：配置 smlAutoChildTableNameDelimiter=- 插入数据为 st,t0=cpu1,t1=4 c1=3 1626006833639000000 则创建的表名为 cpu1-4。
2. 通过在taos.cfg里配置 smlChildTableName 参数来指定。
1. 举例如下：配置 smlChildTableName=tname 插入数据为 st,tname=cpu1,t1=4 c1=3 1626006833639000000 则创建的表名为 cpu1，注意如果多行数据 tname 相同，但是后面的 tag_set 不同，则使用第一行自动建表时指定的 tag_set，其他的行会忽略。
- 通过在 taos.cfg 里配置 smlAutoChildTableNameDelimiter 参数来指定（`@ # 空格 回车 换行 制表符` 除外)，例如配置 smlAutoChildTableNameDelimiter=- 插入数据为 st,t0=cpu1,t1=4 c1=3 1626006833639000000 则创建的表名为 cpu1-4。
- 通过在 taos.cfg 里配置 smlChildTableName 参数来指定，例如配置 smlChildTableName=tname 插入数据为 st,tname=cpu1,t1=4 c1=3 1626006833639000000 则创建的表名为 cpu1，注意如果多行数据 tname 相同，但是后面的 tag_set 不同，则使用第一行自动建表时指定的 tag_set，其他的行会忽略。
2. 如果解析行协议获得的超级表不存在，则会创建这个超级表（不建议手动创建超级表，不然插入数据可能异常）。
3. 如果解析行协议获得子表不存在，则 Schemaless 会按照步骤 1 或 2 确定的子表名来创建子表。
3. 如果解析行协议获得子表不存在，则 schemaless 会按照步骤 1 或 2 确定的子表名来创建子表。
4. 如果数据行中指定的标签列或普通列不存在，则在超级表中增加对应的标签列或普通列（只增不减）。
5. 如果超级表中存在一些标签列或普通列未在一个数据行中被指定取值，那么这些列的值在这一行中会被置为 NULL。
6. 对 BINARY 或 NCHAR 列，如果数据行中所提供值的长度超出了列类型的限制，自动增加该列允许存储的字符长度上限（只增不减），以保证数据的完整保存。
7. 整个处理过程中遇到的错误会中断写入过程，并返回错误代码。
8. 为了提高写入的效率，默认假设同一个超级表中 field_set 的顺序是一样的（第一条数据包含所有的 field，后面的数据按照这个顺序），如果顺序不一样，需要配置参数 smlDataFormat 为 false，否则，数据写入按照相同顺序写入，库中数据会异常，从 3.0.3.0 开始，自动检测顺序是否一致，该配置废弃。
9. 由于 sql 建表表名不支持点号（.），所以 schemaless 也对点号（.）做了处理，如果 schemaless 自动建表的表名如果有点号（.），会自动替换为下划线（\_）。如果手动指定子表名的话，子表名里有点号（.），同样转化为下划线（\_）。
10. taos.cfg 增加 smlTsDefaultName 配置（值为字符串），只在client端起作用，配置后，schemaless自动建表的时间列名字可以通过该配置设置。不配置的话，默认为 _ts。
10. taos.cfg 增加 smlTsDefaultName 配置（字符串类型），只在 client 端起作用，配置后，schemaless 自动建表的时间列名字可以通过该配置设置。不配置的话，默认为 _ts。
11. 无模式写入的数据超级表或子表名区分大小写。
12. 无模式写入仍然遵循 TDengine 对数据结构的底层限制，例如每行数据的总长度不能超过 48KB（从 3.0.5.0 版本开始为 64KB），标签值的总长度不超过 16KB。
@ -147,7 +144,7 @@ InfluxDB行协议的数据将被映射成具有模式的数据，其中，measu
st,t1=3,t2=4,t3=t3 c1=3i64,c3="passit",c2=false,c4=4f64 1626006833639000000
```
该行数据映射生成一个超级表： st， 其包含了 3 个类型为 nchar 的标签，分别是：t1, t2, t3。五个数据列，分别是 ts（timestamp），c1 (bigint），c3(binary)，c2 (bool), c4 (bigint）。映射成为如下 SQL 语句：
该行数据映射生成一个超级表：st， 其包含了 3 个类型为 nchar 的标签，分别是：t1、t2、t3。五个数据列，分别是 ts（timestamp）、c1 (bigint）、c3(binary)、c2 (bool)、c4 (bigint）。映射成为如下 SQL 语句：
```json
create stable st (_ts timestamp, c1 bigint, c2 bool, c3 binary(6), c4 bigint) tags(t1 nchar(1), t2 nchar(1), t3 nchar(2))
@ -164,7 +161,7 @@ st,t1=3,t2=4,t3=t3 c1=3i64,c3="passit",c2=false,c4=4 1626006833639000000
st,t1=3,t2=4,t3=t3 c1=3i64,c3="passit",c2=false,c4=4i 1626006833640000000
```
第一行的数据类型映射将 c4 列定义为 Double， 但是第二行的数据又通过数值后缀方式声明该列为 BigInt， 由此会触发无模式写入的解析错误。
第一行的数据类型映射将 c4 列定义为 Double， 但是第二行的数据又通过数值后缀方式声明该列为 bigInt， 由此会触发无模式写入的解析错误。
如果列前面的行协议将数据列声明为了 binary， 后续的要求长度更长的 binary 长度，此时会触发超级表模式的变更。
@ -299,7 +296,7 @@ writer.write(lineDemo, SchemalessProtocolType.LINE, SchemalessTimestampType.NANO
## 查询写入的数据
运行上节的样例代码，会在 power 数据库l中自动建表，我们可以通过 TDengine CLI 或者应用程序来查询数据。下面给出用 TDengine CLI 查询超级表和 meters 表数据的样例。
运行上节的样例代码，会在 power 数据库中自动建表，我们可以通过 TDengine CLI 或者应用程序来查询数据。下面给出用 TDengine CLI 查询超级表和 meters 表数据的样例。
```shell
taos> show power.stables;

4
docs/zh/07-develop/05-stmt.md
View File

@ -19,9 +19,9 @@ import TabItem from "@theme/TabItem";
我们只推荐使用下面两种形式的 SQL 进行参数绑定写入：
```sql
一、确定子表存在：
一、确定子表存在
1. INSERT INTO meters (tbname, ts, current, voltage, phase) VALUES(?, ?, ?, ?, ?)
二、自动建表：
二、自动建表
1. INSERT INTO meters (tbname, ts, current, voltage, phase, location, group_id) VALUES(?, ?, ?, ?, ?, ?, ?)
2. INSERT INTO ? USING meters TAGS (?, ?) VALUES (?, ?, ?, ?)
```

95
docs/zh/07-develop/07-tmq.md
View File

@ -16,7 +16,7 @@ TDengine 提供了类似于消息队列产品的数据订阅和消费接口。
**注意**
在 TDengine 连接器实现中，对于订阅查询，有以下限制。
- 查询语句限制：订阅查询只能使用 select 语句，并不支持其他类型的SQL，如订阅库，订阅超级表（非 select 方式），insert、update 或 delete 等。
- 查询语句限制：订阅查询只能使用 select 语句，并不支持其他类型的 SQL，如订阅库、订阅超级表（非 select 方式）、insert、update 或 delete 等。
- 原始始数据查询：订阅查询只能查询原始数据，而不能查询聚合或计算结果。
- 时间顺序限制：订阅查询只能按照时间正序查询数据。
@ -28,25 +28,82 @@ TDengine 消费者的概念跟 Kafka 类似，消费者通过订阅主题来接
### 创建参数
创建消费者的参数较多，非常灵活的支持了各种连接类型、 Offset 提交方式、压缩、重连、反序列化等特性。各语言连接器都适用的通用基础配置项如下表所示：
| 参数名称 | 类型 | 参数说明 | 备注 |
| :-----------------------: | :-----: | ------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `td.connect.ip` | string | 服务端的 FQDN | 可以是ip或者host name |
| `td.connect.user` | string | 用户名 | |
| `td.connect.pass` | string | 密码 | |
| `td.connect.port` | integer | 服务端的端口号 | |
| `group.id` | string | 消费组 ID，同一消费组共享消费进度 | <br />**必填项**。最大长度：192，超长将截断。<br />每个topic最多可建立 100 个 consumer group |
| `client.id` | string | 客户端 ID | 最大长度：255，超长将截断。 |
| `auto.offset.reset` | enum | 消费组订阅的初始位置 | <br />`earliest`：default(version < 3.2.0.0)从头开始订阅；<br/>`latest`：default(version >= 3.2.0.0)；仅从最新数据开始订阅；<br/>`none`：没有提交的 offset 无法订阅 |
| `enable.auto.commit` | boolean | 是否启用消费位点自动提交，true：自动提交，客户端应用无需commit；false：客户端应用需要自行 commit | 默认值为 true |
| `auto.commit.interval.ms` | integer | 消费记录自动提交消费位点时间间隔，单位为毫秒 | 默认值为 5000 |
| `msg.with.table.name` | boolean | 是否允许从消息中解析表名, 不适用于列订阅（列订阅时可将 tbname 作为列写入 subquery 语句）（从 3.2.0.0 版本该参数废弃，恒为 true） | 默认关闭 |
| `enable.replay` | boolean | 是否开启数据回放功能 | 默认关闭 |
| `session.timeout.ms` | integer | consumer 心跳丢失后超时时间，超时后会触发 rebalance 逻辑，成功后该 consumer 会被删除（从 3.3.3.0 版本开始支持） | 默认值为 12000，取值范围 [6000， 1800000] |
| `max.poll.interval.ms` | integer | consumer poll 拉取数据间隔的最长时间，超过该时间，会认为该 consumer 离线，触发 rebalance 逻辑，成功后该 consumer 会被删除（从 3.3.3.0 版本开始支持） | 默认值为 300000，[1000，INT32_MAX] |
| `fetch.max.wait.ms` | integer | 服务端单次返回数据的最大耗时（从 3.3.6.0 版本开始支持） | 默认值为 1000，[1，INT32_MAX] |
| `min.poll.rows` | integer | 服务端单次返回数据的最小条数（从 3.3.6.0 版本开始支持） | 默认值为 4096，[1，INT32_MAX] |
| `msg.consume.rawdata` | integer | 消费数据时拉取数据类型为二进制类型，不可做解析操作，内部参数，只用于 taosX 数据迁移（从 3.3.6.0 版本开始支持） | 默认值为 0 表示不起效， 非 0 为 起效 |
#### td.connect.ip
- 说明：服务端的 FQDN
- 类型：string
- 备注：可以是 ip 或者 host name
#### td.connect.user
- 说明：用户名
- 类型：string
#### td.connect.pass
- 说明：密码
- 类型：string
#### td.connect.port
- 说明：服务端的端口号
- 类型：integer
#### group.id
- 说明：消费组 ID，同一消费组共享消费进度
- 类型：string
- 备注：**必填项**。最大长度：192，超长将截断。<br />每个topic最多可建立 100 个 consumer group
#### client.id
- 说明：客户端 ID
- 类型：string
- 备注：最大长度 255，超长将截断
#### auto.offset.reset
- 说明：消费组订阅的初始位置
- 类型：enum
- 备注：<br />`earliest`：default(version < 3.2.0.0)，从头开始订阅；<br/>`latest`：default(version >= 3.2.0.0)，仅从最新数据开始订阅；<br/>`none`：没有提交的 offset 无法订阅。
#### enable.auto.commit
- 说明：是否启用消费位点自动提交
- 类型：boolean
- 备注：true：自动提交，客户端应用无需 commit；false：客户端应用需要自行 commit；默认值为 true。
#### auto.commit.interval.ms
- 说明：消费记录自动提交消费位点时间间隔
- 类型：integer
- 备注：单位为毫秒，默认值为 5000
#### msg.with.table.name
- 说明：是否允许从消息中解析表名
- 类型：boolean
- 备注：不适用于列订阅（列订阅时可将 tbname 作为列写入 subquery 语句），默认关闭。v3.2.0.0 该参数废弃。
#### enable.replay
- 说明：是否开启数据回放功能
- 类型：boolean
- 备注：默认关闭
#### session.timeout.ms
- 说明：consumer 心跳丢失后超时时间
- 类型：integer
- 备注：超时后会触发 rebalance 逻辑，成功后该 consumer 会被删除。默认值为 12000，取值范围 [6000，1800000]。v3.3.3.0 开始支持）
#### max.poll.interval.ms
- 说明：consumer poll 拉取数据间隔的最长时间
- 类型：integer
- 备注：超过该时间，会认为该 consumer 离线，触发 rebalance 逻辑，成功后该 consumer 会被删除。默认值为 300000，[1000，INT32_MAX]。v3.3.3.0 开始支持。
#### fetch.max.wait.ms
- 说明：服务端单次返回数据的最大耗时
- 类型：integer
- 备注：默认值为 1000，[1，INT32_MAX]。v3.3.6.0 开始支持。
#### min.poll.rows
- 说明：服务端单次返回数据的最小条数
- 类型：integer
- 备注：默认值为 4096，[1，INT32_MAX]。v3.3.6.0 开始支持。
#### msg.consume.rawdata
- 说明：消费数据时拉取数据类型为二进制类型，不可做解析操作 `内部参数，只用于 taosX 数据迁移`
- 类型：integer
- 备注：默认值为 0 表示不起效，非 0 为起效。v3.3.6.0 开始支持。
下面是各语言连接器创建参数：
<Tabs defaultValue="java" groupId="lang">

10
docs/zh/07-develop/09-udf.md
View File

@ -323,7 +323,7 @@ def process(input: datablock) -> tuple[output_type]:
```
主要参数说明如下：
- input:datablock 类似二维矩阵，通过成员方法 data(row, col) 读取位于 row 行、col 列的 python 对象
- input:datablock 类似二维矩阵，通过成员方法 data(row, col) 读取位于 row 行、col 列的 Python 对象
- 返回值是一个 Python 对象元组，每个元素类型为输出类型。
#### 聚合函数接口
@ -405,7 +405,7 @@ def finish(buf: bytes) -> output_type:
本文内容由浅入深包括 5 个示例程序，同时也包含大量实用的 debug 技巧。
注意：**UDF 内无法通过 print 函数输出日志，需要自己写文件或用 python 内置的 logging 库写文件**。
注意：**UDF 内无法通过 print 函数输出日志，需要自己写文件或用 Python 内置的 logging 库写文件**。
#### 示例一
@ -652,7 +652,7 @@ tail -20 taospyudf.log
2023-05-25 11:42:34.541 ERROR [1679419] [PyUdf::PyUdf@217] py udf load module failure. error ModuleNotFoundError: No module named 'moment'
```
这是因为 “moment” 所在位置不在 python udf 插件默认的库搜索路径中。怎么确认这一点呢？通过以下命令搜索 taospyudf.log。
这是因为 “moment” 所在位置不在 Python udf 插件默认的库搜索路径中。怎么确认这一点呢？通过以下命令搜索 taospyudf.log。
```shell
grep 'sys path' taospyudf.log | tail -1
@ -664,7 +664,7 @@ grep 'sys path' taospyudf.log | tail -1
2023-05-25 10:58:48.554 INFO [1679419] [doPyOpen@592] python sys path: ['', '/lib/python38.zip', '/lib/python3.8', '/lib/python3.8/lib-dynload', '/lib/python3/dist-packages', '/var/lib/taos//.udf']
```
发现 python udf 插件默认搜索的第三方库安装路径是： /lib/python3/dist-packages，而 moment 默认安装到了 /usr/local/lib/python3.8/dist-packages。下面我们修改 python udf 插件默认的库搜索路径。
发现 Python udf 插件默认搜索的第三方库安装路径是： /lib/python3/dist-packages，而 moment 默认安装到了 /usr/local/lib/python3.8/dist-packages。下面我们修改 Python udf 插件默认的库搜索路径。
先打开 python3 命令行，查看当前的 sys.path。
```python
@ -754,7 +754,7 @@ create or replace aggregate function myspread as '/root/udf/myspread.py' outputt
这个 SQL 语句与创建标量函数的 SQL 语句有两个重要区别。
1. 增加了 aggregate 关键字
2. 增加了 bufsize 关键字，用来指定存储中间结果的内存大小，这个数值可以大于实际使用的数值。本例中间结果是两个浮点数组成的 tuple，序列化后实际占用大小只有 32 个字节，但指定的 bufsize 是128，可以用 python 命令行打印实际占用的字节数
2. 增加了 bufsize 关键字，用来指定存储中间结果的内存大小，这个数值可以大于实际使用的数值。本例中间结果是两个浮点数组成的 tuple，序列化后实际占用大小只有 32 个字节，但指定的 bufsize 是128，可以用 Python 命令行打印实际占用的字节数
```python
>>> len(pickle.dumps((12345.6789, 23456789.9877)))

2
docs/zh/07-develop/15-high.md
View File

@ -374,7 +374,7 @@ SQLWriter 类封装了拼 SQL 和写数据的逻辑。所有的表都没有提
- 已安装 Python3， 推荐版本 >= 3.8
- 已安装 taospy
2. 安装 faster-fifo 代替 python 内置的 multiprocessing.Queue
2. 安装 faster-fifo 代替 Python 内置的 multiprocessing.Queue
```
pip3 install faster-fifo

2
docs/zh/08-operation/01-intro.md
View File

@ -36,7 +36,7 @@ taosAdapter 提供了以下功能：
- RESTful 接口；
- WebSocket 连接；
- 兼容 InfluxDB v1 格式写入；
- 兼容 OpenTSDB JSON 和 Telnet 格式写入；
- 兼容 OpenTSDB JSON 和 TELNET 格式写入；
- 无缝连接到 Telegraf；
- 无缝连接到 collectd；
- 无缝连接到 StatsD；

10
docs/zh/08-operation/02-planning.md
View File

@ -8,7 +8,7 @@ toc_max_heading_level: 4
在这些进程中，taoskeeper、taos-explorer、taosadapter 和 taosx 的资源占用相对较少，通常不需要特别关注。此外，这些进程对存储空间的需求也较低，其占用的 CPU 和内存资源一般为 taosd 进程的十分之一到几分之一（特殊场景除外，如数据同步和历史数据迁移。在这些情况下，涛思数据的技术支持团队将提供一对一的服务）。系统管理员应定期监控这些进程的资源消耗，并及时进行相应处理。
在本节中，我们将重点讨论 TDengine 数据库引擎的核心进程—taosd 的资源规划。合理的资源规划将确保 taosd 进程的高效运行，从而提高整个时序数据平台的性能和稳定性。
在本节中，我们将重点讨论 TDengine 数据库引擎的核心进程 taosd 的资源规划。合理的资源规划将确保 taosd 进程的高效运行，从而提高整个时序数据平台的性能和稳定性。
## 服务器内存需求
@ -154,9 +154,9 @@ TDengine 的多级存储功能在使用上还具备以下优点。
| taosKeeper | 6043 | TCP |
| statsd 格式写入接口 | 6044 | TCP/UDP |
| collectd 格式写入接口 | 6045 | TCP/UDP |
| openTSDB Telnet 格式写入接口 | 6046 | TCP |
| collectd 使用 openTSDB Telnet 格式写入接口 | 6047 | TCP |
| icinga2 使用 openTSDB Telnet 格式写入接口 | 6048 | TCP |
| tcollector 使用 openTSDB Telnet 格式写入接口 | 6049 | TCP |
| openTSDB TELNET 格式写入接口 | 6046 | TCP |
| collectd 使用 openTSDB TELNET 格式写入接口 | 6047 | TCP |
| icinga2 使用 openTSDB TELNET 格式写入接口 | 6048 | TCP |
| tcollector 使用 openTSDB TELNET 格式写入接口 | 6049 | TCP |
| taosX | 6050, 6055 | TCP |
| taosExplorer | 6060 | TCP |

6
docs/zh/08-operation/03-deployment.md
View File

@ -21,7 +21,7 @@ taosd 是 TDengine 集群中最主要的服务组件，本节介绍手动部署
在进行 TDengine 集群部署之前，全面检查所有 dnode 以及应用程序所在物理节点的网络设置至关重要。以下是检查步骤：
- 第 1 步，在每个物理节点上执行 hostname -f 命令，以查看并确认所有节点的hostname 是唯一的。对于应用程序驱动所在的节点，这一步骤可以省略。
- 第 2 步，在每个物理节点上执行 ping host 命令，其中 host 是其他物理节点的 hostname。这一步骤旨在检测当前节点与其他物理节点之间的网络连通性。如果发现无法 ping 通，请立即检查网络和 DNS 设置。对于 Linux 操作系统，请检查 /etc/hosts 文件；对于 Windows 操作系统，请检查C:\Windows\system32\drivers\etc\hosts 文件。网络不通畅将导致无法组建集群，请务必解决此问题。
- 第 2 步，在每个物理节点上执行 ping host 命令，其中 host 是其他物理节点的 hostname。这一步骤旨在检测当前节点与其他物理节点之间的网络连通性。如果发现无法 ping 通，请立即检查网络和 DNS 设置。对于 Linux 操作系统，请检查 /etc/hosts 文件；对于 Windows 操作系统，请检查 `C:\Windows\system32\drivers\etc\hosts` 文件。网络不通畅将导致无法组建集群，请务必解决此问题。
- 第 3 步，在应用程序运行的物理节点上重复上述网络检测步骤。如果发现网络不通畅，应用程序将无法连接到 taosd 服务。此时，请仔细检查应用程序所在物理节点的 DNS 设置或 hosts 文件，确保其配置正确无误。
- 第 4 步，检查端口，确保集群中所有主机在端口 6030 上的 TCP 能够互通。
@ -210,7 +210,7 @@ http {
### 部署 taosX-Agent
有些数据源如 Pi, OPC 等，因为网络条件和数据源访问的限制，taosX 无法直接访问数据源，这种情况下需要部署一个代理服务 taosX-Agent，关于它的详细说明和部署请参考企业版参考手册。
有些数据源如 PI、OPC 等，因为网络条件和数据源访问的限制，taosX 无法直接访问数据源，这种情况下需要部署一个代理服务 taosX-Agent，关于它的详细说明和部署请参考企业版参考手册。
### 部署 taos-Explorer
@ -342,7 +342,7 @@ spec:
### 有状态服务 StatefulSet
根据 Kubernetes 对各类部署的说明，我们将使用 StatefulSet 作为 TDengine 的部署资源类型。 创建文件 tdengine.yaml，其中 replicas 定义集群节点的数量为 3。节点时区为中国（Asia/Shanghai），每个节点分配 5G 标准（standard）存储，你也可以根据实际情况进行相应修改。
根据 Kubernetes 对各类部署的说明，我们将使用 StatefulSet 作为 TDengine 的部署资源类型。 创建文件 tdengine.yaml，其中 replicas 定义集群节点的数量为 3。节点时区为中国（Asia/Shanghai），每个节点分配 5GB 标准（standard）存储，你也可以根据实际情况进行相应修改。
请特别注意 startupProbe 的配置，在 dnode 的 Pod 掉线一段时间后，再重新启动，这个时候新上线的 dnode 会短暂不可用。如果 startupProbe 配置过小，Kubernetes 会认为该 Pod 处于不正常的状态，并尝试重启该 Pod，该 dnode 的 Pod 会频繁重启，始终无法恢复到正常状态。

54
docs/zh/08-operation/04-maintenance.md
View File

@ -12,38 +12,38 @@ sidebar_label: 集群维护
## 数据重整
TDengine 面向多种写入场景，而很多写入场景下，TDengine 的存储会导致数据存储的放大或数据文件的空洞等。这一方面影响数据的存储效率，另一方面也会影响查询效率。为了解决上述问题，TDengine 企业版提供了对数据的重整功能，即 DATA COMPACT 功能，将存储的数据文件重新整理，删除文件空洞和无效数据，提高数据的组织度，从而提高存储和查询的效率。数据重整功能在 3.0.3.0 版本第一次发布，此后又经过了多次迭代优化，建议使用最新版本。
TDengine 面向多种写入场景，而很多写入场景下，TDengine 的存储会导致数据存储的放大或数据文件的空洞等。这一方面影响数据的存储效率，另一方面也会影响查询效率。为了解决上述问题，TDengine 企业版提供了对数据的重整功能，即 data compact 功能，将存储的数据文件重新整理，删除文件空洞和无效数据，提高数据的组织度，从而提高存储和查询的效率。数据重整功能在 3.0.3.0 版本第一次发布，此后又经过了多次迭代优化，建议使用最新版本。
### 语法
```SQL
COMPACT DATABASE db_name [start with 'XXXX'] [end with 'YYYY'] [META_ONLY];
COMPACT [db_name.]VGROUPS IN (vgroup_id1, vgroup_id2, ...) [start with 'XXXX'] [end with 'YYYY'] [META_ONLY];
SHOW COMPACTS;
SHOW COMPACT compact_id;
KILL COMPACT compact_id;
compact DATABASE db_name [start with 'XXXX'] [end with 'YYYY'] [META_ONLY];
compact [db_name.]vgroups IN (vgroup_id1, vgroup_id2, ...) [start with 'XXXX'] [end with 'YYYY'] [META_ONLY];
show compacts;
show compact compact_id;
kill compact compact_id;
```
### 效果
- 扫描并压缩指定的 DB 中所有 VGROUP 中 VNODE 的所有数据文件
- 扫描并压缩 DB 中指定的 VGROUP 列表中 VNODE 的所有数据文件, 若 db_name 为空，则默认为当前数据库
- COMPCAT 会删除被删除数据以及被删除的表的数据
- COMPACT 会合并多个 STT 文件
- 可通过 start with 关键字指定 COMPACT 数据的起始时间
- 可通过 end with 关键字指定 COMPACT 数据的终止时间
- 扫描并压缩指定的 DB 中所有 vgroup 中 vnode 的所有数据文件
- 扫描并压缩 DB 中指定的 vgroup 列表中 vnode 的所有数据文件, 若 db_name 为空，则默认为当前数据库
- compact 会删除被删除数据以及被删除的表的数据
- compact 会合并多个 STT 文件
- 可通过 start with 关键字指定 compact 数据的起始时间
- 可通过 end with 关键字指定 compact 数据的终止时间
- 可通过 `META_ONLY` 关键字指定只 compact 元数据。元数据默认情况下不会 compact。
- COMPACT 命令会返回 COMPACT 任务的 ID
- COMPACT 任务会在后台异步执行，可以通过 SHOW COMPACTS 命令查看 COMPACT 任务的进度
- SHOW 命令会返回 COMPACT 任务的 ID，可以通过 KILL COMPACT 命令终止 COMPACT 任务
- compact 命令会返回 compact 任务的 ID
- compact 任务会在后台异步执行，可以通过 show compacts 命令查看 compact 任务的进度
- show 命令会返回 compact 任务的 ID，可以通过 kill compact 命令终止 compact 任务
### 补充说明
- COMPACT 为异步，执行 COMPACT 命令后不会等 COMPACT 结束就会返回。如果上一个 COMPACT 没有完成则再发起一个 COMPACT 任务，则会等上一个任务完成后再返回。
- COMPACT 可能阻塞写入，尤其是在 stt_trigger = 1 的数据库中，但不阻塞查询。
- compact 为异步，执行 compact 命令后不会等 compact 结束就会返回。如果上一个 compact 没有完成则再发起一个 compact 任务，则会等上一个任务完成后再返回。
- compact 可能阻塞写入，尤其是在 stt_trigger = 1 的数据库中，但不阻塞查询。
## Vgroup Leader 再平衡
## vgroup leader 再平衡
当多副本集群中的一个或多个节点因为升级或其它原因而重启后，有可能出现集群中各个 dnode 负载不均衡的现象，极端情况下会出现所有 vgroup 的 leader 都位于同一个 dnode 的情况。为了解决这个问题，可以使用下面的命令，该命令在 3.0.4.0 版本中首次发布，建议尽可能使用最新版本。
@ -59,11 +59,11 @@ balance vgroup leader database <database_name>; # 再平衡一个 database 内
### 注意
Vgroup 选举本身带有随机性，所以通过选举的重新分布产生的均匀分布也是带有一定的概率，不会完全的均匀。该命令的副作用是影响查询和写入，在vgroup重新选举时，从开始选举到选举出新的 leader 这段时间，这 个vgroup 无法写入和查询。选举过程一般在秒级完成。所有的vgroup会依次逐个重新选举。
vgroup 选举本身带有随机性，所以通过选举的重新分布产生的均匀分布也是带有一定的概率，不会完全的均匀。该命令的副作用是影响查询和写入，在 vgroup 重新选举时，从开始选举到选举出新的 leader 这段时间，这 个vgroup 无法写入和查询。选举过程一般在秒级完成。所有的 vgroup 会依次逐个重新选举。
## 恢复数据节点
当集群中的某个数据节点（dnode）的数据全部丢失或被破坏，比如磁盘损坏或者目录被误删除，可以通过 restore dnode 命令来恢复该数据节点上的部分或全部逻辑节点，该功能依赖多副本中的其它副本进行数据复制，所以只在集群中 dnode 数量大于等于 3 且副本数为 3 的情况下能够工作。
当集群中的某个数据节点（dnode）的数据全部丢失或被破坏，比如磁盘损坏或者目录被误删除，可以通过 `restore dnode` 命令来恢复该数据节点上的部分或全部逻辑节点，该功能依赖多副本中的其它副本进行数据复制，所以只在集群中 dnode 数量大于等于 3 且副本数为 3 的情况下能够工作。
```sql
restore dnode <dnode_id>；# 恢复dnode上的mnode，所有vnode和qnode
@ -79,7 +79,7 @@ restore qnode on dnode <dnode_id>；# 恢复dnode上的qnode
## 分裂虚拟组
当一个 vgroup 因为子表数过多而导致 CPU 或 Disk 资源使用量负载过高时，增加 dnode 节点后，可通过split vgroup命令把该vgroup分裂为两个虚拟组。分裂完成后，新产生的两个 vgroup 承担原来由一个 vgroup 提供的读写服务。该命令在 3.0.6.0 版本第一次发布，建议尽可能使用最新版本。
当一个 vgroup 因为子表数过多而导致 CPU 或 Disk 资源使用量负载过高时，增加 dnode 节点后，可通过 `split vgroup` 命令把该 vgroup 分裂为两个虚拟组。分裂完成后，新产生的两个 vgroup 承担原来由一个 vgroup 提供的读写服务。该命令在 3.0.6.0 版本第一次发布，建议尽可能使用最新版本。
```sql
split vgroup <vgroup_id>
@ -97,8 +97,6 @@ split vgroup <vgroup_id>
从 3.1.1.0 版本开始，TDengine Enterprise 支持在线热更新 `supportVnodes` 这个很重要的 dnode 配置参数。这个参数的原始配置方式是在 `taos.cfg` 配置文件中，表示该 dnode 能够支持的最大的 vnode 数量。当创建一个数据库时需要分配新的 vnode，当删除一个数据库时其 vnode 都会被销毁。
但在线更新 `supportVnodes` 不会产生持久化，当系统重启后，允许的最大 vnode 数量仍然由 taos.cfg 中配置的 `supportVnodes` 决定。
如果通过在线更新或配置文件方式设置的 `supportVnodes` 小于 dnode 当前已经实际存在的 vnode 数量，已经存在的 vnode 不会受影响。但当尝试创建新的 database 时，是否能够创建成功则仍然受实际生效的 `supportVnodes` 参数决定。
## 双副本
@ -107,7 +105,7 @@ split vgroup <vgroup_id>
### 查看 Vgroups 的状态
通过以下 SQL 命令参看双副本数据库中各 Vgroup 的状态：
通过以下 SQL 命令参看双副本数据库中各 vgroup 的状态：
```sql
show arbgroups;
@ -121,15 +119,15 @@ select * from information_schema.ins_arbgroups;
```
is_sync 有以下两种取值：
- 0: Vgroup 数据未达成同步。在此状态下，如果 Vgroup 中的某一 Vnode 不可访问，另一个 Vnode 无法被指定为 `AssignedLeader` role，该 Vgroup 将无法提供服务。
- 1: Vgroup 数据达成同步。在此状态下，如果 Vgroup 中的某一 Vnode 不可访问，另一个 Vnode 可以被指定为 `AssignedLeader` role，该 Vgroup 可以继续提供服务。
- 0: vgroup 数据未达成同步。在此状态下，如果 vgroup 中的某一 vnode 不可访问，另一个 vnode 无法被指定为 `AssignedLeader` role，该 vgroup 将无法提供服务。
- 1: vgroup 数据达成同步。在此状态下，如果 vgroup 中的某一 vnode 不可访问，另一个 vnode 可以被指定为 `AssignedLeader` role，该 vgroup 可以继续提供服务。
assigned_dnode：
- 标识被指定为 AssignedLeader 的 Vnode 的 DnodeId
- 标识被指定为 AssignedLeader 的 vnode 的 DnodeId
- 未指定 AssignedLeader 时，该列显示 NULL
assigned_token：
- 标识被指定为 AssignedLeader 的 Vnode 的 Token
- 标识被指定为 AssignedLeader 的 vnode 的 Token
- 未指定 AssignedLeader时，该列显示 NULL
### 最佳实践

2
docs/zh/08-operation/05-monitor.md
View File

@ -40,7 +40,7 @@ taosKeeper 的配置文件默认位于 `/etc/taos/taoskeeper.toml`。 详细配
#### 导入仪表盘
TDengine 数据源插件已提交至 Grafana 官网，如何安装 TDengine 数据源插件和配置数据源请参考：[安装 Grafana Plugin 并配置数据源](../../third-party/visual/grafana/#安装-grafana-plugin-并配置数据源)。完成插件的安装和数据源的创建后，可以进行 TDinsight 仪表盘的导入。
TDengine 数据源插件已提交至 Grafana 官网，如何安装 TDengine 数据源插件和配置数据源请参考 [安装 Grafana Plugin 并配置数据源](../../third-party/visual/grafana/#安装-grafana-plugin-并配置数据源)。完成插件的安装和数据源的创建后，可以进行 TDinsight 仪表盘的导入。
在 Grafana 的 “Home” -> “Dashboards” 页面，点击位于右上角的 “New” -> “import” 按钮，即可进入 Dashboard 的导入页面，它支持以下两种导入方式。
- Dashboard ID：18180。

16
docs/zh/08-operation/06-gui.md
View File

@ -4,7 +4,7 @@ title: 可视化管理工具
toc_max_heading_level: 4
---
为方便用户更高效地使用和管理 TDengine，TDengine 3.0 版本推出了一个全新的可视化组件—taosExplorer。这个组件旨在帮助用户在不熟悉 SQL 的情况下，也能轻松管理 TDengine 集群。通过 taosExplorer，用户可以轻松查看 TDengine 的运行状态、浏览数据、配置数据源、实现流计算和数据订阅等功能。此外，用户还可以利用taosExplorer 进行数据的备份、复制和同步操作，以及配置用户的各种访问权限。这些功能极大地简化了数据库的使用过程，提高了用户体验。
为方便用户更高效地使用和管理 TDengine，TDengine 3.0 版本推出了一个全新的可视化组件 taosExplorer。这个组件旨在帮助用户在不熟悉 SQL 的情况下，也能轻松管理 TDengine 集群。通过 taosExplorer，用户可以轻松查看 TDengine 的运行状态、浏览数据、配置数据源、实现流计算和数据订阅等功能。此外，用户还可以利用 taosExplorer 进行数据的备份、复制和同步操作，以及配置用户的各种访问权限。这些功能极大地简化了数据库的使用过程，提高了用户体验。
本节介绍可视化管理的基本功能。
@ -38,7 +38,7 @@ toc_max_heading_level: 4
下面通过创建数据库，来熟悉数据浏览器页面的功能和操作，接下来看创建数据库的两种方式：
1. 通过点击图中的 + 号，跳转到创建数据数库页面，点击 创建 按钮，如下图：
1. 通过点击图中的 + 号，跳转到创建数据数库页面，点击“创建”按钮，如下图：
第一步 点击 + 号；
![explorer-02-createDbentry.jpeg](./pic/explorer-02-createDbentry.jpeg "点开 + 号创建数据库")
@ -50,7 +50,7 @@ toc_max_heading_level: 4
弟三步 点击“创建”按钮之后，如下图左边出现数据库名称则创建数据库成功。
![explorer-05-createDbtest01.jpeg](./pic/explorer-05-createDbtest01.jpeg "创建数据库 test01")
2. 通过在 Sql 编辑器中数据 sql 语句，点击 执行 按钮，如下图：
2. 通过在 SQL 编辑器中数据 sql 语句，点击 执行 按钮，如下图：
第一步 输入 sql 语句；
![explorer-06-sqlCreateDb.jpeg](./pic/explorer-06-sqlCreateDb.jpeg "通过 sql 创建数据库")
@ -201,11 +201,11 @@ toc_max_heading_level: 4
## 工具
通过 “工具” 页面，用户可以了解如下 TDengine 周边工具的使用方法。
- TDengine CLI。
- taosBenchmark。
- taosdump。
- TDengine 与 BI 工具的集成，例如 Google Data Studio、Power BI、永洪 BI 等。
- TDengine 与 Grafana、Seeq 的集成。
- TDengine CLI
- taosBenchmark
- taosdump
- TDengine 与 BI 工具的集成，例如 Google Data Studio、Power BI、永洪 BI 等
- TDengine 与 Grafana、Seeq 的集成
## 系统管理

13
docs/zh/08-operation/09-backup.md
View File

@ -8,9 +8,7 @@ toc_max_heading_level: 4
# 1. 基于 taosdump 进行数据备份恢复
taosdump 是一个开源工具，用于支持从运行中的 TDengine 集群备份数据并将备份的数据恢复到相同或另一个正在运行的 TDengine
集群中。taosdump 可以将数据库作为逻辑数据单元进行备份，也可以对数据库中指定时间段内的数据记录进行备份。在使用taosdump
时，可以指定数据备份的目录路径。如果不指定目录路径，taosdump 将默认将数据备份到当前目录。
taosdump 是一个开源工具，用于支持从运行中的 TDengine 集群备份数据并将备份的数据恢复到相同或另一个正在运行的 TDengine 集群中。taosdump 可以将数据库作为逻辑数据单元进行备份，也可以对数据库中指定时间段内的数据记录进行备份。在使用 taosdump 时，可以指定数据备份的目录路径。如果不指定目录路径，taosdump 将默认将数据备份到当前目录。
以下为 taosdump 执行数据备份的使用示例。
@ -18,14 +16,11 @@ taosdump 是一个开源工具，用于支持从运行中的 TDengine 集群备
taosdump -h localhost -P 6030 -D dbname -o /file/path
```
执行上述命令后，taosdump 会连接 localhost:6030 所在的 TDengine 集群，查询数据库 dbname 中的所有数据，并将数据备份到 /f
ile/path 下。
执行上述命令后，taosdump 会连接 localhost:6030 所在的 TDengine 集群，查询数据库 dbname 中的所有数据，并将数据备份到 /file/path 下。
在使用 taosdump 时，如果指定的存储路径已经包含数据文件，taosdump
会提示用户并立即退出，以避免数据被覆盖。这意味着同一存储路径只能用于一次备份。如果你看到相关提示，请谨慎操作，以免误操作导致数据丢失。
在使用 taosdump 时，如果指定的存储路径已经包含数据文件，taosdump 会提示用户并立即退出，以避免数据被覆盖。这意味着同一存储路径只能用于一次备份。如果你看到相关提示，请谨慎操作，以免误操作导致数据丢失。
要将本地指定文件路径中的数据文件恢复到正在运行的 TDengine 集群中，可以通过指定命令行参数和数据文件所在路径来执行 taosdump
命令。以下为 taosdump 执行数据恢复的示例代码。
要将本地指定文件路径中的数据文件恢复到正在运行的 TDengine 集群中，可以通过指定命令行参数和数据文件所在路径来执行 taosdump 命令。以下为 taosdump 执行数据恢复的示例代码。
```shell
taosdump -i /file/path -h localhost -P 6030

6
docs/zh/08-operation/10-disaster.md
View File

@ -27,10 +27,8 @@ TDengine 支持 WAL 机制，实现数据的容错能力，保证数据的高可
- 第 3 步，访问 TDengine 集群 B，创建一个与集群 A 中数据库 db1 参数配置相同的数据库 db2。
- 第 4 步，通过 Web 浏览器访问集群 B 的 taosExplorer 服务，在 “数据浏览器” 页面找到 db2，在 “查看数据库配置” 选项中可以获取该数据库的 DSN，例如 taos+ws://root:taosdata@clusterB:6041/db2
- 第 4 步，通过 Web 浏览器访问集群 B 的 taosExplorer 服务，在 “数据浏览器” 页面找到 db2，在 “查看数据库配置” 选项中可以获取该数据库的 DSN，例如 `taos+ws://root:taosdata@clusterB:6041/db2`
- 第 5 步，在 taosExplorer 服务的“系统管理 - 数据同步”页面新增一个数据同步任务，在任务配置信息中填写需要同步的数据库 db1 和目标数据库 db2 的 DSN，完成创建任务后即可启动数据同步。
- 第 6 步，访问集群 B，可以看到集群 B 中的数据库 db2 源源不断写入来自集群 A 数据库 db1 的数据，直至两个集群的数据库数据量基本保持一致。至此，一个简单的基于
TDengine Enterprise 的数据灾备体系搭建完成。
- 第 6 步，访问集群 B，可以看到集群 B 中的数据库 db2 源源不断写入来自集群 A 数据库 db1 的数据，直至两个集群的数据库数据量基本保持一致。至此，一个简单的基于 TDengine Enterprise 的数据灾备体系搭建完成。

21
docs/zh/08-operation/12-multi.md
View File

@ -5,10 +5,10 @@ toc_max_heading_level: 4
---
本节介绍 TDengine Enterprise 特有的多级存储功能，其作用是将较近的热度较高的数据存储在高速介质上，而时间久远热度很低的数据存储在低成本介质上，达成了以下目标：
- 降低存储成本 -- 将数据分级存储后，海量极冷数据存入廉价存储介质带来显著经济性
- 提升写入性能 -- 得益于每级存储可支持多个挂载点，WAL 预写日志也支持 0 级的多挂载点并行写入，极大提升写入性能（实际场景测得支持持续写入每秒 3 亿测点以上），在机械硬盘上可获得极高磁盘 IO 吞吐（实测可达 2GB/s）
- 方便维护 -- 配置好各级存储挂载点后，系统数据迁移等工作，无需人工干预；存储扩容更灵活、方便
- 对 SQL 透明 -- 无论查询的数据是否跨级，一条 SQL 可返回所有数据，简单高效
- **降低存储成本**：将数据分级存储后，海量极冷数据存入廉价存储介质带来显著经济性
- **提升写入性能**：得益于每级存储可支持多个挂载点，WAL 预写日志也支持 0 级的多挂载点并行写入，极大提升写入性能（实际场景测得支持持续写入每秒 3 亿测点以上），在机械硬盘上可获得极高磁盘 IO 吞吐（实测可达 2GB/s）
- **方便维护**：配置好各级存储挂载点后，系统数据迁移等工作，无需人工干预；存储扩容更灵活、方便
- **对 SQL 透明**：无论查询的数据是否跨级，一条 SQL 可返回所有数据，简单高效
多级存储所涉及的各层存储介质都是本地存储设备。除了本地存储设备之外，TDengine Enterprise 还支持使用对象存储(S3)，将最冷的一批数据保存在最廉价的介质上，以进一步降低存储成本，并在必要时仍然可以进行查询，且数据存储在哪里也对 SQL 透明。支持对象存储在 3.3.0.0 版本中首次发布，建议使用最新版本。
@ -26,9 +26,11 @@ dataDir [path] <level> <primary>
```
- path: 挂载点的文件夹路径。
- level: 介质存储等级，取值为 0，1，2。 0 级存储最新的数据，1 级存储次新的数据，2 级存储最老的数据，省略默认为 0。 各级存储之间的数据流向：0 级存储 -> 1 级存储 -> 2 级存储。 同一存储等级可挂载多个硬盘，同一存储等级上的数据文件分布在该存储等级的所有硬盘上。 需要说明的是，数据在不同级别的存储介质上的移动，是由系统自动完成的，用户无需干预。
- primary: 是否为主挂载点，0（否）或 1（是），省略默认为 1。
- level：介质存储等级，取值为 0、1、2。 0 级存储最新的数据，1 级存储次新的数据，2 级存储最老的数据，省略默认为 0。各级存储之间的数据流向：0 级存储 -> 1 级存储 -> 2 级存储。 同一存储等级可挂载多个硬盘，同一存储等级上的数据文件分布在该存储等级的所有硬盘上。需要说明的是，数据在不同级别的存储介质上的移动，是由系统自动完成的，用户无需干预。
- primary：是否为主挂载点，0（否）或 1（是），省略默认为 1。
在配置中，只允许一个主挂载点的存在（level=0，primary=1），例如采用如下的配置方式：
```shell
dataDir /mnt/data1 0 1
dataDir /mnt/data2 0 0
@ -38,7 +40,8 @@ dataDir /mnt/data5 2 0
dataDir /mnt/data6 2 0
```
**注意** 1. 多级存储不允许跨级配置，合法的配置方案有：仅 0 级，仅 0 级+ 1 级，以及 0 级+ 1 级+ 2 级。而不允许只配置 level=0 和 level=2，而不配置 level=1。
**注意**
1. 多级存储不允许跨级配置，合法的配置方案有：仅 0 级、仅 0 级 + 1 级、以及 0 级 + 1 级 + 2 级。而不允许只配置 level=0 和 level=2，而不配置 level=1。
2. 禁止手动移除使用中的挂载盘，挂载盘目前不支持非本地的网络盘。
### 负载均衡
@ -74,13 +77,13 @@ dataDir /mnt/data6 2 0
| 参数名称 | 参数含义 |
|:---------------------|:-----------------------------------------------|
| s3EndPoint | 用户所在地域的 COS 服务域名，支持 http 和 https，bucket 的区域需要与 endpoint 的保持一致，否则无法访问。 |
| s3EndPoint | 用户所在地域的 COS 服务域名，支持 http 和 https，bucket 的区域需要与 endpoint 的保持一致，否则无法访问 |
| s3AccessKey | 冒号分隔的用户 SecretId:SecretKey。例如：AKIDsQmwsfKxTo2A6nGVXZN0UlofKn6JRRSJ:lIdoy99ygEacU7iHfogaN2Xq0yumSm1E |
| s3BucketName | 存储桶名称，减号后面是用户注册 COS 服务的 AppId。其中 AppId 是 COS 特有，AWS 和阿里云都没有，配置时需要作为 bucket name 的一部分，使用减号分隔。参数值均为字符串类型，但不需要引号。例如：test0711-1309024725 |
| s3UploadDelaySec | data 文件持续多长时间不再变动后上传至 s3，单位：秒。最小值：1；最大值：2592000（30天），默认值 60 秒 |
| s3PageCacheSize | S3 page cache 缓存页数目，单位：页。最小值：4；最大值：1024*1024*1024。 ，默认值 4096|
| s3MigrateIntervalSec | 本地数据文件自动上传 S3 的触发周期，单位为秒。最小值：600；最大值：100000。默认值 3600 |
| s3MigrateEnabled | 是否自动进行 S3 迁移，默认值为 0，表示关闭自动 S3 迁移，可配置为 1。 |
| s3MigrateEnabled | 是否自动进行 S3 迁移，默认值为 0，表示关闭自动 S3 迁移，可配置为 1 |
#### 检查配置参数可用性

9
docs/zh/08-operation/14-user.md
View File

@ -56,7 +56,7 @@ alter_user_clause: {
- pass：修改用户密码。
- enable：是否启用用户。1 表示启用此用户，0 表示禁用此用户。
- sysinfo ：用户是否可查看系统信息。1 表示可以查看系统信息，0 表示不可以查看系统信息
- createdb：用户是否可创建数据库。1 表示可以创建数据库，0 表示不可以创建数据库。// 从 TDengine 企业版 3.3.2.0 开始支持
- createdb：用户是否可创建数据库。1 表示可以创建数据库，0 表示不可以创建数据库。从 TDengine 企业版 3.3.2.0 开始支持。
如下 SQL 禁用 test 用户。
```sql
@ -76,7 +76,7 @@ drop user user_name
### 库和表的授权
在 TDengine 中，库和表的权限分为 read （读）和 write （写）两种。这些权限可以单独授予，也可以同时授予用户。
在 TDengine 中，库和表的权限分为 read 和 write 两种。这些权限可以单独授予，也可以同时授予用户。
- read 权限：拥有 read 权限的用户仅能查询库或表中的数据，而无法对数据进行修改或删除。这种权限适用于需要访问数据但不需要对数据进行写入操作的场景，如数据分析师、报表生成器等。
- write 权限：拥有 write 权限的用户可以向库或表中写入数据。这种权限适用于需要对数据进行写入操作的场景，如数据采集器、数据处理器等。如果只拥有 write 权限而没有 read 权限，则只能写入数据但不能查询数据。
@ -101,10 +101,11 @@ resources ：{
```
相关参数说明如下。
- resources ：可以访问的库或表。. 之前为数据库名称，. 之后为表名称。dbname.tbname 的意思是名为 dbname 的数据库中的 tbname 表必须为普通表或超级表。dbname.* 的意思是名为 dbname 的数据库中的所有表。*.* 的意思是所有数据库中的所有表。
- resources：可以访问的库或表。`.` 之前为数据库名称，`.` 之后为表名称。`dbname.tbname` 的意思是名为 dbname 的数据库中的 tbname 表必须为普通表或超级表。`dbname.*` 的意思是名为 dbname 的数据库中的所有表。`*.*` 的意思是所有数据库中的所有表。
- tag_filter：超级表的过滤条件。
上述 SQL 既可以授权一个库、所有库，也可以授权一个库下的普通表或超级表，还可以通过 dbname.tbname 和 with 子句的组合授权符合过滤条件的一张超级表下的所有子表。
上述 SQL 既可以授权一个库、所有库，也可以授权一个库下的普通表或超级表，还可以通过 `dbname.tbname` 和 `with` 子句的组合授权符合过滤条件的一张超级表下的所有子表。
如下 SQL 将数据库 power 的 read 权限授权给用户 test。
```sql
grant read on power to test

46
docs/zh/08-operation/16-security.md
View File

@ -28,20 +28,20 @@ ALTER USER TEST DROP HOST HOST_NAME1
```
说明
- 开源版和企业版本都能添加成功，且可以查询到，但是开源版本不会对 IP 做任何限制。
- create user u_write pass 'taosdata1' host 'iprange1','iprange2', 可以一次添加多个 iprange, 服务端会做去重，去重的逻辑是需要 iprange 完全一样
- 默认会把 127.0.0.1 添加到白名单列表，且在白名单列表可以查询
- `create user u_write pass 'taosdata1' host 'iprange1','iprange2'`，可以一次添加多个 ip range，服务端会做去重，去重的逻辑是需要 ip range 完全一样
- 默认会把 `127.0.0.1` 添加到白名单列表，且在白名单列表可以查询
- 集群的节点 IP 集合会自动添加到白名单列表，但是查询不到。
- taosadaper 和 taosd 不在一个机器的时候，需要把 taosadaper IP 手动添加到 taosd 白名单列表中
- 集群情况下，各个节点 enableWhiteList 成一样，或者全为 false,或者全为 true, 要不然集群无法启动
- 白名单变更生效时间 1s，不超过 2s, 每次变更对收发性能有些微影响（多一次判断，可以忽略），变更完之后、影响忽略不计, 变更过程中对集群没有影响，对正在访问客户端也没有影响（假设这些客户端的 IP 包含在 white list 内）
- 如果添加两个 ip range, 192.168.1.1/16(假设为 A), 192.168.1.1/24(假设为 B), 严格来说，A 包含了 B，但是考虑情况太复杂，并不会对 A 和 B 做合并
- 要删除的时候，必须严格匹配。 也就是如果添加的是 192.168.1.1/24, 要删除也是 192.168.1.1/24
- 集群情况下，各个节点 enableWhiteList 成一样，或者全为 false，或者全为 true，要不然集群无法启动
- 白名单变更生效时间 1s，不超过 2s，每次变更对收发性能有些微影响（多一次判断，可以忽略），变更完之后、影响忽略不计，变更过程中对集群没有影响，对正在访问客户端也没有影响（假设这些客户端的 IP 包含在 white list 内）
- 如果添加两个 ip range，192.168.1.1/16(假设为 A)，192.168.1.1/24(假设为 B)，严格来说，A 包含了 B，但是考虑情况太复杂，并不会对 A 和 B 做合并
- 要删除的时候，必须严格匹配。 也就是如果添加的是 192.168.1.1/24，要删除也是 192.168.1.1/24
- 只有 root 才有权限对其他用户增删 ip white list
- 兼容之前的版本，但是不支持从当前版本回退到之前版本
- x.x.x.x/32 和 x.x.x.x 属于同一个 iprange, 显示为 x.x.x.x
- 如果客户端拿到的 0.0.0.0/0, 说明没有开启白名单
- x.x.x.x/32 和 x.x.x.x 属于同一个 iprange，显示为 x.x.x.x
- 如果客户端拿到的 0.0.0.0/0，说明没有开启白名单
- 如果白名单发生了改变， 客户端会在 heartbeat 里检测到。
- 针对一个 user, 添加的 IP 个数上限是 2048
- 针对一个 user，添加的 IP 个数上限是 2048
## 审计日志
@ -53,7 +53,7 @@ TDengine 先对用户操作进行记录和管理，然后将这些作为审计
| 参数名称 | 参数含义 |
|:-------------:|:--------------------------------------------------------:|
|audit | 是否打开审计日志，默认值为 0。1 为开启，0 为关闭 |
|audit | 是否打开审计日志，1 为开启，0 为关闭，默认值为 0。 |
|monitorFqdn | 接收审计日志的 taosKeeper 所在服务器的 FQDN |
|monitorPort | 接收审计日志的 taosKeeper 服务所用端口 |
|monitorCompaction | 上报数据时是否进行压缩 |
@ -64,7 +64,7 @@ TDengine 先对用户操作进行记录和管理，然后将这些作为审计
| 参数名称 | 参数含义 |
|:-------------:|:--------------------------------------------------------:|
|auditDB | 用于存放审计日志的数据库的名字，默认值为 "audit" ，taosKeeper 在收到上报的审计日志后会判断该数据库是否存在，如果不存在会自动创建它 |
|auditDB | 用于存放审计日志的数据库的名字，默认值为 "audit"，taosKeeper 在收到上报的审计日志后会判断该数据库是否存在，如果不存在会自动创建 |
### 数据格式
@ -88,19 +88,19 @@ TDengine 先对用户操作进行记录和管理，然后将这些作为审计
taosKeeper 会依据上报的审计数据在相应的数据库中自动建立超级表用于存储数据。该超级表的定义如下
```sql
CREATE STABLE operations(ts timestamp, details VARCHAR(64000)， User VARCHAR(25), Operation VARCHAR(20), db VARCHAR(65), resource VARCHAR(193), client_add(25)) TAGS (clusterID VARCHAR(64) );
create stable operations(ts timestamp, details varchar(64000)， user varchar(25), operation varchar(20), db varchar(65), resource varchar(193), client_add(25)) tags (clusterID varchar(64) );
```
其中：
其中
1. db 为操作涉及的 database，resource 为操作涉及的资源。
2. User 和 Operation 为数据列，表示哪个用户在该对象上进行了什么操作
2. user 和 operation 为数据列，表示哪个用户在该对象上进行了什么操作
3. timestamp 为时间戳列，表示操作发生时的时间
4. details 为该操作的一些补充细节，在大多数操作下是所执行的操作的 SQL 语句。
5. client_add 为客户端地址，包括 ip 和端口
### 操作列表
目前审计日志中所记录的操作列表以及每个操作中各字段的含义如下表（注：因为每个操作的实加者即 user 字段、时间戳字段和client_add在所有操作中的含义相同，下表不包含）
目前审计日志中所记录的操作列表以及每个操作中各字段的含义（因为每个操作的施加者，即 user、client_add、时间戳字段在所有操作中的含义相同，下表不再描述）
| 操作 | Operation | DB | Resource | Details |
| ----------------| ----------| ---------| ---------| --------|
@ -110,8 +110,8 @@ CREATE STABLE operations(ts timestamp, details VARCHAR(64000)， User VARCHAR(25
| create stable | createStb | db name | stable name | SQL |
| alter stable | alterStb | db name | stable name | SQL |
| drop stable | dropStb | db name | stable name | SQL |
| create user | createUser | NULL | 被创建的用户名 | 用户属性参数, (password除外) |
| alter user | alterUser | NULL | 被修改的用户名 | 修改密码操作记录的是被修改的参数和新值 (password除外) ；其他操作记录SQL |
| create user | createUser | NULL | 被创建的用户名 | 用户属性参数， (password 除外) |
| alter user | alterUser | NULL | 被修改的用户名 | 修改密码记录被修改的参数和新值 (password 除外)，其他操作记录 SQL |
| drop user | dropUser | NULL | 被删除的用户名 | SQL |
| create topic | createTopic | topic 所在 DB | 创建的 topic 名字 | SQL |
| drop topic | cropTopic | topic 所在 DB | 删除的 topic 名字 | SQL |
@ -123,7 +123,7 @@ CREATE STABLE operations(ts timestamp, details VARCHAR(64000)， User VARCHAR(25
| create qnode | createQnode | NULL | dnodeId | SQL |
| drop qnode | dropQnode | NULL | dnodeId | SQL |
| login | login | NULL | NULL | appName |
| create stream | createStream | NULL | 所创建的 strem 名 | SQL |
| create stream | createStream | NULL | 所创建的 stream 名 | SQL |
| drop stream | dropStream | NULL | 所删除的 stream 名 | SQL |
| grant privileges| grantPrivileges | NULL | 所授予的用户 | SQL |
| remove privileges | revokePrivileges | NULL | 被收回权限的用户 | SQL |
@ -171,7 +171,7 @@ database_option: {
```
主要参数说明如下。
encrypt_algorithm：指定数据采用的加密算法。默认是 none，即不采用加密。sm4 表示采用 SM4 加密算法
- encrypt_algorithm：指定数据采用的加密算法。默认是 none，即不采用加密。sm4 表示采用 SM4 加密算法
### 查看加密配置
@ -186,7 +186,7 @@ select name, `encrypt_algorithm` from ins_databases;
### 查看节点密钥状态
通过以下的SQL命令参看节点密钥状态：
通过以下的 SQL 命令参看节点密钥状态。
```sql
show encryptions;
@ -200,12 +200,12 @@ select * from information_schema.ins_encryptions;
```
key_status 有三种取值：
- 当节点未设置密钥时，状态列显示 unset。
- 当密钥被检验成功并且加载后，状态列显示 loaded.
- 当节点未启动，key的状态无法被探知时，状态列显示 unknown
- 当密钥被检验成功并且加载后，状态列显示 loaded。
- 当节点未启动，key 的状态无法被探知时，状态列显示 unknown。
### 更新密钥配置
当节点的硬件配置发生变更时，需要通过以下命令更新密钥，与离线配置密钥的命令相同：
当节点的硬件配置发生变更时，需要通过以下命令更新密钥，与离线配置密钥的命令相同。
```shell
taosd -y {encryptKey}

48
docs/zh/10-third-party/01-collection/11-kafka.md vendored
View File

@ -4,7 +4,7 @@ title: TDengine Kafka Connector
description: 使用 TDengine Kafka Connector 的详细指南
---
TDengine Kafka Connector 包含两个插件: TDengine Source Connector 和 TDengine Sink Connector。用户只需提供简单的配置文件，就可以将 Kafka 中指定 topic 的数据（批量或实时）同步到 TDengine， 或将 TDengine 中指定数据库的数据（批量或实时）同步到 Kafka。
TDengine Kafka Connector 包含 TDengine Source Connector 和 TDengine Sink Connector 两个插件。用户只需提供简单的配置文件，就可以将 Kafka 中指定 topic 的数据（批量或实时）同步到 TDengine，或将 TDengine 中指定数据库的数据（批量或实时）同步到 Kafka。
## 什么是 Kafka Connect？
@ -346,16 +346,16 @@ curl -X DELETE http://localhost:8083/connectors/TDengineSourceConnector
以下配置项对 TDengine Sink Connector 和 TDengine Source Connector 均适用。
1. `name`: connector 名称。
1. `connector.class`: connector 的完整类名， 如: com.taosdata.kafka.connect.sink.TDengineSinkConnector。
1. `tasks.max`: 最大任务数, 默认 1。
1. `topics`: 需要同步的 topic 列表， 多个用逗号分隔, 如 `topic1,topic2`。
1. `connection.url`: TDengine JDBC 连接字符串， 如 `jdbc:TAOS://127.0.0.1:6030`。
1. `name`：connector 名称。
1. `connector.class`：connector 的完整类名，例如如 com.taosdata.kafka.connect.sink.TDengineSinkConnector。
1. `tasks.max`：最大任务数, 默认 1。
1. `topics`：需要同步的 topic 列表，多个用逗号分隔, 如 `topic1,topic2`。
1. `connection.url`：TDengine JDBC 连接字符串，如 `jdbc:TAOS://127.0.0.1:6030`。
1. `connection.user`：TDengine 用户名，默认 root。
1. `connection.password`：TDengine 用户密码，默认 taosdata。
1. `connection.attempts`：最大尝试连接次数。默认 3。
1. `connection.backoff.ms`：创建连接失败重试时间隔时间，单位为 ms。默认 5000。
1. `data.precision`: 使用 InfluxDB 行协议格式时，时间戳的精度。可选值为：
1. `data.precision`：使用 InfluxDB 行协议格式时，时间戳的精度。可选值为：
1. ms：表示毫秒
1. us：表示微秒
1. ns：表示纳秒
@ -364,29 +364,29 @@ curl -X DELETE http://localhost:8083/connectors/TDengineSourceConnector
1. `connection.database`：目标数据库名。如果指定的数据库不存在会则自动创建。自动建库使用的时间精度为纳秒。默认值为 null。为 null 时目标数据库命名规则参考 `connection.database.prefix` 参数的说明
2. `connection.database.prefix`：当 connection.database 为 null 时, 目标数据库的前缀。可以包含占位符 '$\{topic}'。比如 kafka_$\{topic}, 对于主题 'orders' 将写入数据库 'kafka_orders'。默认 null。当为 null 时，目标数据库的名字和主题的名字是一致的。
3. `batch.size`: 分批写入每批记录数。当 Sink Connector 一次接收到的数据大于这个值时将分批写入。
4. `max.retries`: 发生错误时的最大重试次数。默认为 1。
5. `retry.backoff.ms`: 发送错误时重试的时间间隔。单位毫秒，默认为 3000。
6. `db.schemaless`: 数据格式，可选值为：
3. `batch.size`：分批写入每批记录数。当 Sink Connector 一次接收到的数据大于这个值时将分批写入。
4. `max.retries`：发生错误时的最大重试次数。默认为 1。
5. `retry.backoff.ms`：发送错误时重试的时间间隔。单位毫秒，默认为 3000。
6. `db.schemaless`：数据格式，可选值为：
1. line：代表 InfluxDB 行协议格式
2. json : 代表 OpenTSDB JSON 格式
2. json：代表 OpenTSDB JSON 格式
3. telnet：代表 OpenTSDB Telnet 行协议格式
### TDengine Source Connector 特有的配置
1. `connection.database`: 源数据库名称，无缺省值。
1. `connection.database`：源数据库名称，无缺省值。
1. `topic.prefix`：数据导入 kafka 时使用的 topic 名称的前缀。默认为空字符串 ""。
1. `timestamp.initial`: 数据同步起始时间。格式为'yyyy-MM-dd HH:mm:ss'，若未指定则从指定 DB 中最早的一条记录开始。
1. `poll.interval.ms`: 检查是否有新建或删除的表的时间间隔，单位为 ms。默认为 1000。
1. `fetch.max.rows` : 检索数据库时最大检索条数。 默认为 100。
1. `query.interval.ms`: 从 TDengine 一次读取数据的时间跨度，需要根据表中的数据特征合理配置，避免一次查询的数据量过大或过小；在具体的环境中建议通过测试设置一个较优值，默认值为 0，即获取到当前最新时间的所有数据。
1. `out.format` : 结果集输出格式。`line` 表示输出格式为 InfluxDB Line 协议格式，`json` 表示输出格式是 json。默认为 line。
1. `topic.per.stable`: 如果设置为 true，表示一个超级表对应一个 Kafka topic，topic的命名规则 `<topic.prefix><topic.delimiter><connection.database><topic.delimiter><stable.name>`；如果设置为 false，则指定的 DB 中的所有数据进入一个 Kafka topic，topic 的命名规则为 `<topic.prefix><topic.delimiter><connection.database>`
1. `topic.ignore.db`: topic 命名规则是否包含 database 名称，true 表示规则为 `<topic.prefix><topic.delimiter><stable.name>`，false 表示规则为 `<topic.prefix><topic.delimiter><connection.database><topic.delimiter><stable.name>`，默认 false。此配置项在 `topic.per.stable` 设置为 false 时不生效。
1. `topic.delimiter`: topic 名称分割符，默认为 `-`。
1. `read.method`: 从 TDengine 读取数据方式，query 或是 subscription。默认为 subscription。
1. `subscription.group.id`: 指定 TDengine 数据订阅的组 id，当 `read.method` 为 subscription 时，此项为必填项。
1. `subscription.from`: 指定 TDengine 数据订阅起始位置，latest 或是 earliest。默认为 latest。
1. `timestamp.initial`：数据同步起始时间。格式为'yyyy-MM-dd HH:mm:ss'，若未指定则从指定 DB 中最早的一条记录开始。
1. `poll.interval.ms`：检查是否有新建或删除的表的时间间隔，单位为 ms。默认为 1000。
1. `fetch.max.rows`：检索数据库时最大检索条数。默认为 100。
1. `query.interval.ms`：从 TDengine 一次读取数据的时间跨度，需要根据表中的数据特征合理配置，避免一次查询的数据量过大或过小；在具体的环境中建议通过测试设置一个较优值，默认值为 0，即获取到当前最新时间的所有数据。
1. `out.format`：结果集输出格式。`line` 表示输出格式为 InfluxDB Line 协议格式，`json` 表示输出格式是 json。默认为 line。
1. `topic.per.stable`：如果设置为 true，表示一个超级表对应一个 Kafka topic，topic的命名规则 `<topic.prefix><topic.delimiter><connection.database><topic.delimiter><stable.name>`；如果设置为 false，则指定的 DB 中的所有数据进入一个 Kafka topic，topic 的命名规则为 `<topic.prefix><topic.delimiter><connection.database>`
1. `topic.ignore.db`：topic 命名规则是否包含 database 名称，true 表示规则为 `<topic.prefix><topic.delimiter><stable.name>`，false 表示规则为 `<topic.prefix><topic.delimiter><connection.database><topic.delimiter><stable.name>`，默认 false。此配置项在 `topic.per.stable` 设置为 false 时不生效。
1. `topic.delimiter`：topic 名称分割符，默认为 `-`。
1. `read.method`：从 TDengine 读取数据方式，query 或是 subscription。默认为 subscription。
1. `subscription.group.id`：指定 TDengine 数据订阅的组 id，当 `read.method` 为 subscription 时，此项为必填项。
1. `subscription.from`：指定 TDengine 数据订阅起始位置，latest 或是 earliest。默认为 latest。
## 其他说明

3
docs/zh/10-third-party/05-bi/01-looker.md vendored
View File

@ -21,8 +21,11 @@ TDengine连接器兼容TDengine Cloud和TDengine Server两种类型的数据源
- URL 和 TDengine Cloud Token，可以从 TDengine Cloud 的实例列表中获取。
- 数据库名称和超级表名称。
- 查询数据的开始时间和结束时间。
第 2 步，Looker Studio 会根据配置自动加载所配置的 TDengine 数据库下的超级表的字段和标签。
第 3 步，点击页面右上角的 Explore 按钮，即查看从 TDengine 数据库中加载的数据。
第 4 步，根据需求，利用 Looker Studio 提供的图表，进行数据可视化的配置。
**注意** 在第一次使用时，请根据页面提示，对 Looker Studio 的 TDengine 连接器进行访问授权。

3
docs/zh/10-third-party/07-tool/03-qstudio.md vendored
View File

@ -19,8 +19,7 @@ qStudio 是一款免费的多平台 SQL 数据分析工具，可以轻松浏览
![qStudio 连接 TDengine](./qstudio/qstudio-connect-tdengine.webp)
2. 配置 TDengine 连接，填入主机地址、端口号、用户名和密码。如果 TDengine 部署在本机，可以只填用户名和密码，默认用户名为 root，默认密码为 taosdata。点击“Test”可以对连接是否可用进行测试。如果本机没有安装 TDengine Java
连接器，qStudio 会提示下载安装。
2. 配置 TDengine 连接，填入主机地址、端口号、用户名和密码。如果 TDengine 部署在本机，可以只填用户名和密码，默认用户名为 root，默认密码为 taosdata。点击 “Test” 可以对连接是否可用进行测试。如果本机没有安装 TDengine Java 连接器，qStudio 会提示下载安装。
![下载 Java 连接器](./qstudio/qstudio-jdbc-connector-download.webp)

52
docs/zh/14-reference/01-components/01-taosd.md
View File

@ -12,18 +12,18 @@ taosd 命令行参数如下
- -a `<json file>`：指定一个 JSON 文件，其中包含服务启动时的各项配置参数，其格式形如 `{"fqdn":"td1"}`，关于配置参数的细节请参考下一节
- -c `<directory>`：指定配置文件所在目录
- -s：打印 SDB 信息
- -C: 打印配置信息
- -e: 指定环境变量的字符串，例如：`-e 'TAOS_FQDN=td1'`
- -E: 指定环境变量的文件路径，默认是 `./.env`，.env 文件中的内容可以是 `TAOS_FQDN=td1`
- -o: 指定日志输入方式，可选 `stdout`, `stderr`, `/dev/null`, `<directory>`,` <directory>/<filename>`, `<filename>`
- -k: 获取机器码
- -dm: 启用内存调度
- -V: 打印版本信息
- -C：打印配置信息
- -e：指定环境变量的字符串，例如 `-e 'TAOS_FQDN=td1'`
- -E：指定环境变量的文件路径，默认是 `./.env`，.env 文件中的内容可以是 `TAOS_FQDN=td1`
- -o：指定日志输入方式，可选 `stdout`、`stderr`、`/dev/null`、`<directory>`、` <directory>/<filename>`、`<filename>`
- -k：获取机器码
- -dm：启用内存调度
- -V：打印版本信息
## 配置参数
:::note
配置文件参数修改后，需要重启*taosd*服务，或客户端应用才能生效
配置文件参数修改后，通常需要重启 *taosd* 服务，或客户端应用才能生效
:::
### 连接相关
@ -143,7 +143,7 @@ taosd 命令行参数如下
- 支持版本：v3.3.4.0 版本之后取消
#### maxRetryWaitTime
- 说明：重连最大超时时间, 从重试时候开始计算
- 说明：重连最大超时时间，从重试时候开始计算
- 类型：整数
- 单位：毫秒
- 默认值：10000
@ -1347,7 +1347,7 @@ charset 的有效值是 UTF-8。
#### forceReadConfig
- 说明：配置文件所在目录
- 类型：整数；0:使用持久化的配置参数，1:使用配置文件中的配置参数；
- 类型：整数；0：使用持久化的配置参数，1：使用配置文件中的配置参数；
- 默认值：0
- 最小值：0
- 最大值：1
@ -1362,7 +1362,7 @@ charset 的有效值是 UTF-8。
#### assert
- 说明：断言控制开关
- 类型：整数；0:关闭，1：开启
- 类型：整数；0：关闭，1：开启
- 默认值：0
- 最小值：0
- 最大值：1
@ -1440,7 +1440,7 @@ charset 的有效值是 UTF-8。
### 压缩参数
#### fPrecision
- 说明：设置 float 类型浮点数压缩精度, 小于此值的浮点数尾数部分将被截断
- 说明：设置 float 类型浮点数压缩精度，小于此值的浮点数尾数部分将被截断
- 类型：浮点数
- 默认值：0.00000001
- 最小值：0.00000001
@ -1554,7 +1554,7 @@ taosd 会将监控指标上报给 taosKeeper，这些监控指标会被 taosKeep
| :------------- | :-------- | :------ | :--------------------------------------------- |
| \_ts | TIMESTAMP | | timestamp |
| tables\_num | DOUBLE | | vgroup 中 table 数量 |
| status | DOUBLE | | vgroup 状态, 取值范围 unsynced = 0, ready = 1 |
| status | DOUBLE | | vgroup 状态，取值范围 0：unsynced、1：ready |
| vgroup\_id | VARCHAR | TAG | vgroup id |
| database\_name | VARCHAR | TAG | vgroup 所属的 database 名字 |
| cluster\_id | VARCHAR | TAG | cluster id |
@ -1583,10 +1583,10 @@ taosd 会将监控指标上报给 taosKeeper，这些监控指标会被 taosKeep
| io\_write\_disk | DOUBLE | | 磁盘 io 吞吐率，从 `/proc/<taosd_pid>/io` 中读取的 write_bytes。单位 byte/s |
| vnodes\_num | DOUBLE | | dnode 上 vnodes 数量 |
| masters | DOUBLE | | dnode 上 master node 数量 |
| has\_mnode | DOUBLE | | dnode 是否包含 mnode，取值范围 包含=1,不包含=0 |
| has\_qnode | DOUBLE | | dnode 是否包含 qnode，取值范围 包含=1,不包含=0 |
| has\_snode | DOUBLE | | dnode 是否包含 snode，取值范围 包含=1,不包含=0 |
| has\_bnode | DOUBLE | | dnode 是否包含 bnode，取值范围 包含=1,不包含=0 |
| has\_mnode | DOUBLE | | dnode 是否包含 mnode，取值范围：1：包含、0：不包含 |
| has\_qnode | DOUBLE | | dnode 是否包含 qnode，取值范围：1：包含、0：不包含 |
| has\_snode | DOUBLE | | dnode 是否包含 snode，取值范围：1：包含、0：不包含 |
| has\_bnode | DOUBLE | | dnode 是否包含 bnode，取值范围：1：包含、0：不包含 |
| error\_log\_count | DOUBLE | | error 总数 |
| info\_log\_count | DOUBLE | | info 总数 |
| debug\_log\_count | DOUBLE | | debug 总数 |
@ -1602,7 +1602,7 @@ taosd 会将监控指标上报给 taosKeeper，这些监控指标会被 taosKeep
| field | type | is\_tag | comment |
| :---------- | :-------- | :------ | :--------------------------------------- |
| \_ts | TIMESTAMP | | timestamp |
| status | DOUBLE | | dnode 状态,取值范围 ready=1，offline =0 |
| status | DOUBLE | | dnode 状态,取值范围 1：ready、0：offline |
| dnode\_id | VARCHAR | TAG | dnode id |
| dnode\_ep | VARCHAR | TAG | dnode endpoint |
| cluster\_id | VARCHAR | TAG | cluster id |
@ -1645,7 +1645,7 @@ taosd 会将监控指标上报给 taosKeeper，这些监控指标会被 taosKeep
| field | type | is\_tag | comment |
| :---------- | :-------- | :------ | :------------------------------------------------------------------------------------------------------- |
| \_ts | TIMESTAMP | | timestamp |
| role | DOUBLE | | mnode 角色， 取值范围 offline = 0,follower = 100,candidate = 101,leader = 102,error = 103,learner = 104 |
| role | DOUBLE | | mnode 角色，取值范围 0：offline、100：follower、101：candidate、102：leader、103：error、104、learne |
| mnode\_id | VARCHAR | TAG | master node id |
| mnode\_ep | VARCHAR | TAG | master node endpoint |
| cluster\_id | VARCHAR | TAG | cluster id |
@ -1657,7 +1657,7 @@ taosd 会将监控指标上报给 taosKeeper，这些监控指标会被 taosKeep
| field | type | is\_tag | comment |
| :------------- | :-------- | :------ | :------------------------------------------------------------------------------------------------------ |
| \_ts | TIMESTAMP | | timestamp |
| vnode\_role | DOUBLE | | vnode 角色，取值范围 offline = 0,follower = 100,candidate = 101,leader = 102,error = 103,learner = 104 |
| vnode\_role | DOUBLE | | vnode 角色，取值范围 0：offline、100：follower、101：candidate、102：leader、103：error、104、learne |
| vgroup\_id | VARCHAR | TAG | dnode id |
| dnode\_id | VARCHAR | TAG | dnode id |
| database\_name | VARCHAR | TAG | vgroup 所属的 database 名字 |
@ -1671,7 +1671,7 @@ taosd 会将监控指标上报给 taosKeeper，这些监控指标会被 taosKeep
| :---------- | :-------- | :------ | :--------------------------------------- |
| \_ts | TIMESTAMP | | timestamp |
| count | DOUBLE | | sql 数量 |
| result | VARCHAR | TAG | sql的执行结果，取值范围 Success, Failed |
| result | VARCHAR | TAG | sql 的执行结果，取值范围 Success、Failed |
| username | VARCHAR | TAG | 执行 sql 的 user name |
| sql\_type | VARCHAR | TAG | sql 类型，取值范围 inserted_rows |
| dnode\_id | VARCHAR | TAG | dnode id |
@ -1687,9 +1687,9 @@ taosd 会将监控指标上报给 taosKeeper，这些监控指标会被 taosKeep
| :---------- | :-------- | :------ | :---------------------------------------- |
| \_ts | TIMESTAMP | | timestamp |
| count | DOUBLE | | sql 数量 |
| result | VARCHAR | TAG | sql的执行结果，取值范围 Success, Failed |
| result | VARCHAR | TAG | sql 的执行结果，取值范围 Success、Failed |
| username | VARCHAR | TAG | 执行 sql 的 user name |
| sql\_type | VARCHAR | TAG | sql类型，取值范围 select, insert，delete |
| sql\_type | VARCHAR | TAG | sql 类型，取值范围 select、insert、delete |
| cluster\_id | VARCHAR | TAG | cluster id |
### taos\_slow\_sql 表
@ -1700,7 +1700,7 @@ taosd 会将监控指标上报给 taosKeeper，这些监控指标会被 taosKeep
| :---------- | :-------- | :------ | :---------------------------------------------------- |
| \_ts | TIMESTAMP | | timestamp |
| count | DOUBLE | | sql 数量 |
| result | VARCHAR | TAG | sql的执行结果，取值范围 Success, Failed |
| result | VARCHAR | TAG | sql 的执行结果，取值范围 Success、Failed |
| username | VARCHAR | TAG | 执行 sql 的 user name |
| duration | VARCHAR | TAG | sql 执行耗时，取值范围 3-10s,10-100s,100-1000s,1000s- |
| cluster\_id | VARCHAR | TAG | cluster id |
@ -1713,10 +1713,10 @@ taosd 会将监控指标上报给 taosKeeper，这些监控指标会被 taosKeep
| :------------- | :-------- | :------ | :---------------------------------------------------- |
| start\_ts | TIMESTAMP | | sql 开始执行的客户端时间，单位ms，主键 |
| request\_id | UINT64_T | | sql 请求的 request id，为 hash 生产的随机值 |
| query\_time | INT32_T | | sql 执行耗时, 单位ms |
| query\_time | INT32_T | | sql 执行耗时，单位ms |
| code | INT32_T | | sql 执行返回码，0表示成功 |
| error\_info | VARCHAR | | sql 执行失败时，记录的错误信息 |
| type | INT8_T | | sql 语句的类型（1-查询，2-写入，4-其他） |
| type | INT8_T | | sql 语句的类型（1：查询，2：写入，4：其他） |
| rows\_num | INT64_T | | sql 执行结果的记录数目 |
| sql | VARCHAR | | sql 语句的字符串 |
| process\_name | VARCHAR | | 进程名称 |

36
docs/zh/14-reference/01-components/04-taosx.md
View File

@ -42,17 +42,17 @@ tmq+ws://root:taosdata@localhost:6030/db1?timeout=never
- taos：使用查询接口从 TDengine 获取数据
- tmq：启用数据订阅从 TDengine 获取数据
- local：数据备份或恢复
- pi: 启用 pi-connector从 pi 数据库中获取数据
- pi：启用 pi-connector从 pi 数据库中获取数据
- opc：启用 opc-connector 从 opc-server 中获取数据
- mqtt: 启用 mqtt-connector 获取 mqtt-broker 中的数据
- kafka: 启用 Kafka 连接器从 Kafka Topics 中订阅消息写入
- influxdb: 启用 influxdb 连接器从 InfluxDB 获取数据
- mqtt：启用 mqtt-connector 获取 mqtt-broker 中的数据
- kafka：启用 Kafka 连接器从 Kafka Topics 中订阅消息写入
- influxdb： 启用 influxdb 连接器从 InfluxDB 获取数据
- csv：从 CSV 文件解析数据
2. +protocol 包含如下选项：
- +ws: 当 driver 取值为 taos 或 tmq 时使用，表示使用 rest 获取数据。不使用 +ws 则表示使用原生连接获取数据，此时需要 taosx 所在的服务器安装 taosc。
- +ua: 当 driver 取值为 opc 时使用，表示采集的数据的 opc-server 为 opc-ua
- +da: 当 driver 取值为 opc 时使用，表示采集的数据的 opc-server 为 opc-da
- +ws：当 driver 取值为 taos 或 tmq 时使用，表示使用 rest 获取数据。不使用 +ws 则表示使用原生连接获取数据，此时需要 taosx 所在的服务器安装 taosc。
- +ua：当 driver 取值为 opc 时使用，表示采集的数据的 opc-server 为 opc-ua
- +da：当 driver 取值为 opc 时使用，表示采集的数据的 opc-server 为 opc-da
3. host:port 表示数据源的地址和端口。
4. object 表示具体的数据源，可以是TDengine的数据库、超级表、表，也可以是本地备份文件的路径，也可以是对应数据源服务器中的数据库。
@ -251,7 +251,7 @@ d4,2017-07-14T10:40:00.006+08:00,-2.740636,10,-0.893545,7,California.LosAngles
- `monitor.port`：`taosKeeper` 服务的端口，默认`6043`。
- `monitor.interval`：向 `taosKeeper` 发送指标的频率，默认为每 10 秒一次，只有 1 到 10 之间的值才有效。
- `log.path`：日志文件存放的目录。
- `log.level`：日志级别，可选值为 "error", "warn", "info", "debug", "trace"。
- `log.level`：日志级别，可选值为 "error"、"warn"、"info"、"debug"、"trace"。
- `log.compress`：日志文件滚动后的文件是否进行压缩。
- `log.rotationCount`：日志文件目录下最多保留的文件数，超出数量的旧文件被删除。
- `log.rotationSize`：触发日志文件滚动的文件大小（单位为字节），当日志文件超出此大小后会生成一个新文件，新的日志会写入新文件。
@ -401,8 +401,8 @@ taosX 会将监控指标上报给 taosKeeper，这些监控指标会被 taosKeep
| -------------------------- | ----------------------------------------------------------------------------- |
| sys_cpu_cores | 系统 CPU 核数 |
| sys_total_memory | 系统总内存，单位：字节 |
| sys_used_memory | 系统已用内存, 单位：字节 |
| sys_available_memory | 系统可用内存, 单位：字节 |
| sys_used_memory | 系统已用内存，单位：字节 |
| sys_available_memory | 系统可用内存，单位：字节 |
| process_uptime | taosX 运行时长，单位：秒 |
| process_id | taosX 进程 ID |
| running_tasks | taosX 当前执行任务数 |
@ -420,8 +420,8 @@ taosX 会将监控指标上报给 taosKeeper，这些监控指标会被 taosKeep
| -------------------------- | ----------------------------------------------------------------------------- |
| sys_cpu_cores | 系统 CPU 核数 |
| sys_total_memory | 系统总内存，单位：字节 |
| sys_used_memory | 系统已用内存, 单位：字节 |
| sys_available_memory | 系统可用内存, 单位：字节 |
| sys_used_memory | 系统已用内存，单位：字节 |
| sys_available_memory | 系统可用内存，单位：字节 |
| process_uptime | agent 运行时长，单位：秒 |
| process_id | agent 进程 id |
| process_cpu_percent | agent 进程占用 CPU 百分比 |
@ -457,7 +457,7 @@ taosX 会将监控指标上报给 taosKeeper，这些监控指标会被 taosKeep
| 字段 | 描述 |
| --------------------- | -------------------------------------------------------------------- |
| read_concurrency | 并发读取数据源的数据 worker 数, 也等于并发写入 TDengine 的 worker 数 |
| read_concurrency | 并发读取数据源的数据 worker 数，也等于并发写入 TDengine 的 worker 数 |
| total_stables | 需要迁移的超级表数据数量 |
| total_updated_tags | 累计更新 tag 数 |
| total_created_tables | 累计创建子表数 |
@ -566,9 +566,9 @@ taosX Parser 插件是一个要求用 C/Rust 语言开发的 C ABI 兼容动态
**函数签名**：parser_resp_t parser_new(char* ctx, uint32_t len);
char* ctx: 用户自定义配置字符串。
char* ctx：用户自定义配置字符串。
uint32_t len: 该字符串的二进制长度（不含 `\0`）。
uint32_t len：该字符串的二进制长度（不含 `\0`）。
**返回值**：
@ -597,11 +597,11 @@ const char* parser_mutate(
);
```
`void* parser`: parser_new 生成的对象指针;
`void* parser`：parser_new 生成的对象指针;
`const uint8_t* in_ptr`：输入 Payload 的指针;
`uint32_t in_len`: 输入 Payload 的 bytes 长度（不含 `\0`）;
`uint32_t in_len`：输入 Payload 的 bytes 长度（不含 `\0`）;
`const void* uint8_t* out_ptr`:输出 JSON 字符串的指针（不含 \0）。当 out_ptr 指向为空时，表示输出为空。
@ -615,4 +615,4 @@ const char* parser_mutate(
**函数签名**： void parser_free(void* parser);
void* parser: parser_new 生成的对象指针。
void* parser：parser_new 生成的对象指针。

16
docs/zh/14-reference/01-components/05-taosx-agent.md
View File

@ -3,23 +3,23 @@ title: taosX-Agent 参考手册
sidebar_label: taosX-Agent
---
本节讲述如何部署 `Agent` (for `taosX`)。使用之前需要安装 TDengine Enterprise 安装包之后，taosX-Agent 用于在部分数据接入场景，如 Pi, OPC UA, OPC DA 等对访问数据源有一定限制或者网络环境特殊的场景下，可以将 taosX-Agent 部署在靠近数据源的环境中甚至与数据源在相同的服务器上，由 taosX-Agent 负责从数据源读取数据并发送给 taosX。
本节讲述如何部署 `Agent` (for `taosX`)。使用之前需要安装 TDengine Enterprise 安装包之后，taosX-Agent 用于在部分数据接入场景，如 Pi、OPC UA、OPC DA 等对访问数据源有一定限制或者网络环境特殊的场景下，可以将 taosX-Agent 部署在靠近数据源的环境中甚至与数据源在相同的服务器上，由 taosX-Agent 负责从数据源读取数据并发送给 taosX。
## 配置
`Agent` 默认的配置文件位于 `/etc/taos/agent.toml`, 包含以下配置项：
`Agent` 默认的配置文件位于 `/etc/taos/agent.toml`，包含以下配置项：
- `endpoint`: 必填，`taosX` 的 GRPC 服务地址。
- `token`: 必填，在 `Explorer` 上创建 `Agent` 时，产生的 Token。
- `endpoint`：必填，`taosX` 的 GRPC 服务地址。
- `token`：必填，在 `Explorer` 上创建 `Agent` 时，产生的 Token。
- `instanceId`：当前 taosx-agent 服务的实例 ID，如果同一台机器上启动了多个 taosx-agent 实例，必须保证各个实例的实例 ID 互不相同。
- `compression`: 非必填，可配置为 `true` 或 `false`, 默认为 `false`。配置为`true`, 则开启 `Agent` 和 `taosX` 通信数据压缩。
- `in_memory_cache_capacity`: 非必填，表示可在内存中缓存的最大消息批次数，可配置为大于 0 的整数。默认为 `64`。
- `compression`：非必填，可配置为 `true` 或 `false`，默认为 `false`。配置为`true`，则开启 `Agent` 和 `taosX` 通信数据压缩。
- `in_memory_cache_capacity`：非必填，表示可在内存中缓存的最大消息批次数，可配置为大于 0 的整数。默认为 `64`。
- `client_port_range.min`：非必填，取值范围 `[49152-65535]`，默认为 `49152`，当 agent 向 taosx 创建 socket 连接时，socket 客户端会随机监听一个端口，此配置限制了端口范围的最小值。
- `client_port_range.max`：非必填，取值范围 `[49152-65535]`，默认为 `65535`，此配置限制了端口范围的最大值。
- `log_level`: 非必填，日志级别，默认为 `info`, 同 `taosX` 一样，支持 `error`，`warn`，`info`，`debug`，`trace` 五级。已弃用，请使用 `log.level` 代替。
- `log_level`：非必填，日志级别，默认为 `info`，同 `taosX` 一样，支持 `error`、`warn`、`info`、`debug`、`trace` 五级。已弃用，请使用 `log.level` 代替。
- `log_keep_days`：非必填，日志保存天数，默认为 `30` 天。已弃用，请使用 `log.keepDays` 代替。
- `log.path`：日志文件存放的目录。
- `log.level`：日志级别，可选值为 "error", "warn", "info", "debug", "trace"。
- `log.level`：日志级别，可选值为 "error"、"warn"、"info"、"debug"、"trace"。
- `log.compress`：日志文件滚动后的文件是否进行压缩。
- `log.rotationCount`：日志文件目录下最多保留的文件数，超出数量的旧文件被删除。
- `log.rotationSize`：触发日志文件滚动的文件大小（单位为字节），当日志文件超出此大小后会生成一个新文件，新的日志会写入新文件。

80
docs/zh/14-reference/01-components/06-taoskeeper.md
View File

@ -13,7 +13,7 @@ taosKeeper 是 TDengine 3.0 版本监控指标的导出工具，通过简单的
taosKeeper 有两种安装方式：
- 安装 TDengine 官方安装包的同时会自动安装 taosKeeper, 详情请参考[TDengine 安装](../../../get-started/)。
- 安装 TDengine 官方安装包的同时会自动安装 taosKeeper，详情请参考 [TDengine 安装](../../../get-started/)。
- 单独编译 taosKeeper 并安装，详情请参考 [taosKeeper](https://github.com/taosdata/taoskeeper) 仓库。
@ -354,7 +354,7 @@ taos_cluster_info_first_ep_dnode_id{cluster_id="554014120921134497"} 1
| 指标名称 | 类型 | 含义 |
| ------------------------------ | ------- | ---------------------------------------------------------------------------------------- |
| taos_d_info_status | gauge | dnode 状态，标签 value 表示状态， ready 表示正常， offline 表示下线， unknown 表示未知。 |
| taos_d_info_status | gauge | dnode 状态，标签 value 表示状态、ready 表示正常、offline 表示下线、unknown 表示未知。 |
| taos_dnodes_info_cpu_cores | gauge | CPU 核心数 |
| taos_dnodes_info_cpu_engine | gauge | 该 dnode 的进程所使用的 CPU 百分比（取值范围 0~100） |
| taos_dnodes_info_cpu_system | gauge | 该 dnode 所在节点的系统使用的 CPU 百分比（取值范围 0~100） |
@ -474,64 +474,64 @@ taos_cluster_info_first_ep_dnode_id{cluster_id="554014120921134497"} 1
##### taos_m_info_role
- **标签**:
- `cluster_id`: 集群 id
- `mnode_ep`: mnode 端点
- `mnode_id`: mnode id
- `value`: 角色值（该 mnode 的状态，取值范围：offline, follower, candidate, leader, error, learner）
- **类型**: gauge
- **含义**: mnode 角色
- `cluster_id`：集群 id
- `mnode_ep`：mnode 端点
- `mnode_id`：mnode id
- `value`：角色值（该 mnode 的状态，取值范围：offline、follower、candidate、leader、error、learner）
- **类型**：gauge
- **含义**：mnode 角色
##### taos_taos_sql_req_count
- **标签**:
- `cluster_id`: 集群 id
- `result`: 请求结果（取值范围： Success, Failed）
- `sql_type`: SQL 类型（取值范围：select, insert，inserted_rows, delete）
- `username`: 用户名
- **类型**: gauge
- **含义**: SQL 请求数量
- `cluster_id`：集群 id
- `result`：请求结果（取值范围：Success、Failed）
- `sql_type`：SQL 类型（取值范围：select、insert、inserted_rows、delete）
- `username`：用户名
- **类型**：gauge
- **含义**：SQL 请求数量
##### taos_taosd_sql_req_count
- **标签**:
- `cluster_id`: 集群 id
- `dnode_ep`: dnode 端点
- `dnode_id`: dnode id
- `result`: 请求结果（取值范围： Success, Failed）
- `sql_type`: SQL 类型（取值范围：select, insert，inserted_rows, delete）
- `username`: 用户名
- `vgroup_id`: 虚拟组 id
- **类型**: gauge
- **含义**: SQL 请求数量
- `cluster_id`：集群 id
- `dnode_ep`：dnode 端点
- `dnode_id`：dnode id
- `result`：请求结果（取值范围：Success、Failed）
- `sql_type`：SQL 类型（取值范围：select、insert、inserted_rows、delete）
- `username`：用户名
- `vgroup_id`：虚拟组 id
- **类型**：gauge
- **含义**：SQL 请求数量
##### taos_taosd_vgroups_info_status
- **标签**:
- `cluster_id`: 集群 id
- `database_name`: 数据库名称
- `vgroup_id`: 虚拟组 id
- **类型**: gauge
- **含义**: 虚拟组状态。 0 为 unsynced，表示没有 leader 选出；1 为 ready。
- `cluster_id`：集群 id
- `database_name`：数据库名称
- `vgroup_id`：虚拟组 id
- **类型**：gauge
- **含义**：虚拟组状态。 0 为 unsynced，表示没有 leader 选出；1 为 ready。
##### taos_taosd_vgroups_info_tables_num
- **标签**:
- `cluster_id`: 集群 id
- `database_name`: 数据库名称
- `vgroup_id`: 虚拟组 id
- **类型**: gauge
- **含义**: 虚拟组表数量
- `cluster_id`：集群 id
- `database_name`：数据库名称
- `vgroup_id`：虚拟组 id
- **类型**：gauge
- **含义**：虚拟组表数量
##### taos_taosd_vnodes_info_role
- **标签**:
- `cluster_id`: 集群 id
- `database_name`: 数据库名称
- `dnode_id`: dnode id
- `value`: 角色值（取值范围：offline, follower, candidate, leader, error, learner）
- `vgroup_id`: 虚拟组 id
- **类型**: gauge
- **含义**: 虚拟节点角色
- `cluster_id`：集群 id
- `database_name`：数据库名称
- `dnode_id`：dnode id
- `value`：角色值（取值范围：offline、follower、candidate、leader、error、learner）
- `vgroup_id`：虚拟组 id
- **类型**：gauge
- **含义**：虚拟节点角色
### 抽取配置

6
docs/zh/14-reference/01-components/07-explorer.md
View File

@ -128,7 +128,7 @@ cors = true
- `addr`：taosExplorer 服务绑定的 IPv4 地址，默认为 `0.0.0.0`。如需修改，请配置为 `localhost` 之外的地址以对外提供服务。
- `ipv6`：taosExplorer 服务绑定的 IPv6 地址，默认不绑定 IPv6 地址。
- `instanceId`：当前 explorer 服务的实例 ID，如果同一台机器上启动了多个 explorer 实例，必须保证各个实例的实例 ID 互不相同。
- `log_level`：日志级别，可选值为 "error", "warn", "info", "debug", "trace"。此参数已弃用，请使用 `log.level` 代替。
- `log_level`：日志级别，可选值为 "error"、"warn"、"info"、"debug"、"trace"。此参数已弃用，请使用 `log.level` 代替。
- `cluster`：TDengine 集群的 taosAdapter 地址。
- `cluster_native`：TDengine 集群的原生连接地址，默认关闭。
- `x_api`：taosX 的 gRPC 地址。
@ -137,7 +137,7 @@ cors = true
- `ssl.certificate`：SSL 证书（如果同时设置了 certificate 与 certificate_key 两个参数，则启用 HTTPS 服务，否则不启用）。
- `ssl.certificate_key`：SSL 证书密钥。
- `log.path`：日志文件存放的目录。
- `log.level`：日志级别，可选值为 "error", "warn", "info", "debug", "trace"。
- `log.level`：日志级别，可选值为 "error"、"warn"、"info"、"debug"、"trace"。
- `log.compress`：日志文件滚动后的文件是否进行压缩。
- `log.rotationCount`：日志文件目录下最多保留的文件数，超出数量的旧文件被删除。
- `log.rotationSize`：触发日志文件滚动的文件大小（单位为字节），当日志文件超出此大小后会生成一个新文件，新的日志会写入新文件。
@ -226,4 +226,4 @@ sc.exe stop taos-explorer # Windows
其他功能页面，如 `数据写入-数据源` 等页面，为企业版特有功能，您可以点击查看和简单体验，并不能实际使用。
如果由于网络原因无法完成注册环节，则需要在有外网的环境注册完毕，然后把注册好的 /etc/taos/explorer-register.cfg 替换到内网环境。
如果由于网络原因无法完成注册环节，则需要在有外网的环境注册完毕，然后把注册好的 `/etc/taos/explorer-register.cfg` 替换到内网环境。

52
docs/zh/14-reference/02-tools/08-taos-cli.md
View File

@ -37,20 +37,20 @@ taos> quit
### 基础参数
可通过配置命令行参数来改变 TDengine CLI 的行为。以下为常用的几个命令行参数：
- -h HOST: 要连接的 TDengine 服务端所在服务器的 FQDN, 默认值： 127.0.0.1 。
- -P PORT: 指定服务端所用端口号，默认值：6030 。
- -u USER: 连接时使用的用户名，默认值：root 。
- -p PASSWORD: 连接服务端时使用的密码，特殊字符如 `! & ( ) < > ; |` 需使用字符 `\` 进行转义处理, 默认值：taosdata 。
- -?, --help: 打印出所有命令行参数。
- -s COMMAND: 以非交互模式执行的 SQL 命令。
- -h HOST：要连接的 TDengine 服务端所在服务器的 FQDN, 默认值：127.0.0.1。
- -P PORT：指定服务端所用端口号，默认值：6030。
- -u USER：连接时使用的用户名，默认值：root。
- -p PASSWORD：连接服务端时使用的密码，特殊字符如 `! & ( ) < > ; |` 需使用字符 `\` 进行转义处理, 默认值：taosdata。
- -?, --help：打印出所有命令行参数。
- -s COMMAND：以非交互模式执行的 SQL 命令。
使用 `-s` 参数可进行非交互式执行 SQL，执行完成后退出，此模式适合在自动化脚本中使用。
如以下命令连接到服务器 h1.taos.com, 执行 -s 指定的 SQL:
如以下命令连接到服务器 h1.taos.com, 执行 -s 指定的 SQL：
```bash
taos -h my-server -s "use db; show tables;"
```
- -c CONFIGDIR: 指定配置文件目录。
- -c CONFIGDIR：指定配置文件目录。
Linux 环境下默认为 `/etc/taos`，该目录下的配置文件默认名称为 `taos.cfg`。
使用 `-c` 参数改变 `taosc` 客户端加载配置文件的位置，客户端配置参数参考 [客户端配置](../../components/taosc)。
@ -61,23 +61,23 @@ taos> quit
### 高级参数
- -a AUTHSTR: 连接服务端的授权信息。
- -A: 通过用户名和密码计算授权信息。
- -B: 设置 BI 工具显示模式，设置后所有输出都遵循 BI 工具的格式进行输出。
- -C: 打印 -c 指定的目录中 `taos.cfg` 的配置参数。
- -d DATABASE: 指定连接到服务端时使用的数据库。
- -E dsn: 使用 WebSocket DSN 连接云服务或者提供 WebSocket 连接的服务端。
- -f FILE: 以非交互模式执行 SQL 脚本文件。文件中一个 SQL 语句只能占一行。
- -k: 测试服务端运行状态，0: unavailable，1: network ok，2: service ok，3: service degraded，4: exiting 。
- -l PKTLEN: 网络测试时使用的测试包大小。
- -n NETROLE: 网络连接测试时的测试范围，默认为 `client`, 可选值为 `client`、`server` 。
- -N PKTNUM: 网络测试时使用的测试包数量。
- -r: 将时间列转化为无符号 64 位整数类型输出(即 C 语言中 uint64_t) 。
- -R: 使用 RESTful 模式连接服务端。
- -t: 测试服务端启动状态，状态同 -k 。
- -w DISPLAYWIDTH: 客户端列显示宽度。
- -z TIMEZONE: 指定时区，默认为本地时区。
- -V: 打印出当前版本号。
- -a AUTHSTR：连接服务端的授权信息。
- -A：通过用户名和密码计算授权信息。
- -B：设置 BI 工具显示模式，设置后所有输出都遵循 BI 工具的格式进行输出。
- -C：打印 -c 指定的目录中 `taos.cfg` 的配置参数。
- -d DATABASE：指定连接到服务端时使用的数据库。
- -E dsn：使用 WebSocket DSN 连接云服务或者提供 WebSocket 连接的服务端。
- -f FILE：以非交互模式执行 SQL 脚本文件。文件中一个 SQL 语句只能占一行。
- -k：测试服务端运行状态，0：unavailable、1：network ok、2：service ok、3：service degraded、4：exiting。
- -l PKTLEN：网络测试时使用的测试包大小。
- -n NETROLE：网络连接测试时的测试范围，默认为 `client`，可选值为 `client`、`server`。
- -N PKTNUM：网络测试时使用的测试包数量。
- -r：将时间列转化为无符号 64 位整数类型输出(即 C 语言中 uint64_t)。
- -R：使用 RESTful 模式连接服务端。
- -t：测试服务端启动状态，状态同 -k。
- -w DISPLAYWIDTH：客户端列显示宽度。
- -z TIMEZONE：指定时区，默认为本地时区。
- -V：打印出当前版本号。
## 数据导出/导入
@ -123,7 +123,7 @@ taos> SET MAX_BINARY_DISPLAY_WIDTH 120;
- 在 TDengine CLI 中使用 `alter user` 命令可以修改用户密码，缺省密码为 `taosdata`。
- Ctrl+C 中止正在进行中的查询。
- 执行 `RESET QUERY CACHE` 可清除本地表 Schema 的缓存。
- 批量执行 SQL 语句。可以将一系列的 TDengine CLI 命令（以英文 ; 结尾，每个 SQL 语句为一行）按行存放在文件里，在 TDengine CLI 里执行命令 `source <file-name>` 自动执行该文件里所有的 SQL 语句。
- 批量执行 SQL 语句。可以将一系列的 TDengine CLI 命令（以英文 `;` 结尾，每个 SQL 语句为一行）按行存放在文件里，在 TDengine CLI 里执行命令 `source <file-name>` 自动执行该文件里所有的 SQL 语句。
## 错误代码表
在 TDengine 3.3.4.8 版本后 TDengine CLI 在返回错误信息中返回了具体错误码，用户可到 TDengine 官网错误码页面查找具体原因及解决措施，见：[错误码参考表](https://docs.taosdata.com/reference/error-code/)

218
docs/zh/14-reference/02-tools/10-taosbenchmark.md
View File

@ -25,7 +25,7 @@ taosBenchmark
```
在无参数运行时，taosBenchmark 默认连接 `/etc/taos/taos.cfg` 中指定的 TDengine 集群。
连接成功后，会默认创建智能电表示例数据库 test，创建超级表 meters, 创建子表 1 万，每子写入数据 1 万条，若 test 库已存在，默认会先删再建。
连接成功后，会默认创建智能电表示例数据库 test，创建超级表 meters，创建子表 1 万，每子写入数据 1 万条，若 test 库已存在，默认会先删再建。
### 命令行模式
@ -52,7 +52,7 @@ taosBenchmark -f <json file>
| -c/--config-dir \<dir> | TDengine 集群配置文件所在的目录，默认路径是 /etc/taos |
| -h/--host \<host> | 指定要连接的 TDengine 服务端的 FQDN，默认值为 localhost |
| -P/--port \<port> | 要连接的 TDengine 服务器的端口号，默认值为 6030 |
| -I/--interface \<insertMode> | 插入模式，可选项有 taosc, rest, stmt, sml, sml-rest, 分别对应普通写入、restful 接口写入、参数绑定接口写入、schemaless 接口写入、restful schemaless 接口写入 (由 taosAdapter 提供)。默认值为 taosc |
| -I/--interface \<insertMode> | 插入模式，可选项有 taosc、rest、stmt、sml、sml-rest，分别对应普通写入、restful 接口写入、参数绑定接口写入、schemaless 接口写入、restful schemaless 接口写入 (由 taosAdapter 提供)。默认值为 taosc |
| -u/--user \<user> | 用于连接 TDengine 服务端的用户名，默认为 root |
| -U/--supplement-insert | 写入数据而不提前建数据库和表，默认关闭 |
| -p/--password \<passwd> | 用于连接 TDengine 服务端的密码，默认值为 taosdata |
@ -65,15 +65,15 @@ taosBenchmark -f <json file>
| -S/--timestampstep \<stepLength> | 每个子表中插入数据的时间戳步长，单位是 ms，默认值是 1 |
| -n/--records \<recordNum> | 每个子表插入的记录数，默认值为 10000 |
| -d/--database \<dbName> | 所使用的数据库的名称，默认值为 test |
| -b/--data-type \<colType> | 指定超级表普通列数据类型, 多个使用逗号分隔，默认值： "FLOAT,INT,FLOAT" 如：`taosBenchmark -b "FLOAT,BINARY(8),NCHAR(16)"`|
| -b/--data-type \<colType> | 指定超级表普通列数据类型，多个使用逗号分隔，默认值："FLOAT,INT,FLOAT" 如：`taosBenchmark -b "FLOAT,BINARY(8),NCHAR(16)"`|
| -A/--tag-type \<tagType> | 指定超级表标签列数据类型，多个使用逗号分隔，默认值："INT,BINARY(24)" 如：`taosBenchmark -A "INT,BINARY(8),NCHAR(8)"`|
| -l/--columns \<colNum> | 超级表的数据列的总数量。如果同时设置了该参数和 `-b/--data-type`，则最后的结果列数为两者取大。如果本参数指定的数量大于 `-b/--data-type` 指定的列数，则未指定的列类型默认为 INT， 例如: `-l 5 -b float,double`， 那么最后的列为 `FLOAT,DOUBLE,INT,INT,INT`。如果 columns 指定的数量小于或等于 `-b/--data-type` 指定的列数，则结果为 `-b/--data-type` 指定的列和类型，例如: `-l 3 -b float,double,float,bigint`，那么最后的列为 `FLOAT,DOUBLE,FLOAT,BIGINT` |
| -l/--columns \<colNum> | 超级表的数据列的总数量。如果同时设置了该参数和 `-b/--data-type`，则最后的结果列数为两者取大。如果本参数指定的数量大于 `-b/--data-type` 指定的列数，则未指定的列类型默认为 INT，例如 `-l 5 -b float,double`，那么最后的列为 `FLOAT,DOUBLE,INT,INT,INT`。如果 columns 指定的数量小于或等于 `-b/--data-type` 指定的列数，则结果为 `-b/--data-type` 指定的列和类型，例如：`-l 3 -b float,double,float,bigint`，那么最后的列为 `FLOAT,DOUBLE,FLOAT,BIGINT` |
| -L/--partial-col-num \<colNum> | 指定某些列写入数据，其他列数据为 NULL。默认所有列都写入数据 |
| -w/--binwidth \<length> | nchar 和 binary 类型的默认长度，默认值为 64 |
| -m/--table-prefix \<tablePrefix> | 子表名称的前缀，默认值为 "d" |
| -E/--escape-character | 开关参数，指定在超级表和子表名称中是否使用转义字符。默认值为不使用 |
| -C/--chinese | 开关参数，指定 nchar 和 binary 是否使用 Unicode 中文字符。默认值为不使用 |
| -N/--normal-table | 开关参数，指定只创建普通表，不创建超级表。默认值为 false。仅当插入模式为 taosc, stmt, rest 模式下可以使用 |
| -N/--normal-table | 开关参数，指定只创建普通表，不创建超级表。默认值为 false。仅当插入模式为 taosc、stmt、rest 模式下可以使用 |
| -M/--random | 开关参数，插入数据为生成的随机值。默认值为 false。若配置此参数，则随机生成要插入的数据。对于数值类型的 标签列/数据列，其值为该类型取值范围内的随机值。对于 NCHAR 和 BINARY 类型的 标签列/数据列，其值为指定长度范围内的随机字符串 |
| -x/--aggr-func | 开关参数，指示插入后查询聚合函数。默认值为 false |
| -y/--answer-yes | 开关参数，要求用户在提示后确认才能继续 |默认值为 false 。
@ -93,162 +93,162 @@ taosBenchmark -f <json file>
本节所列参数适用于所有功能模式。
- **filetype** : 功能分类，可选值为 `insert`, `query` 和 `subscribe`。分别对应插入、查询和订阅功能。每个配置文件中只能指定其中之一。
- **cfgdir** : TDengine 客户端配置文件所在的目录，默认路径是 /etc/taos 。
- **filetype**：功能分类，可选值为 `insert`、`query` 和 `subscribe`。分别对应插入、查询和订阅功能。每个配置文件中只能指定其中之一。
- **cfgdir**：TDengine 客户端配置文件所在的目录，默认路径是 /etc/taos 。
- **host** : 指定要连接的 TDengine 服务端的 FQDN，默认值为 localhost 。
- **host**：指定要连接的 TDengine 服务端的 FQDN，默认值为 localhost 。
- **port** : 要连接的 TDengine 服务器的端口号，默认值为 6030 。
- **port**：要连接的 TDengine 服务器的端口号，默认值为 6030 。
- **user** : 用于连接 TDengine 服务端的用户名，默认为 root 。
- **user**：用于连接 TDengine 服务端的用户名，默认为 root 。
- **password** : 用于连接 TDengine 服务端的密码，默认值为 taosdata。
- **password**：用于连接 TDengine 服务端的密码，默认值为 taosdata。
### 写入配置参数
写入场景下 `filetype` 必须设置为 `insert`，该参数及其它通用参数详见 [通用配置参数](#通用配置参数)
- **keep_trying** : 失败后进行重试的次数，默认不重试。需使用 v3.0.9 以上版本。
- **keep_trying**：失败后进行重试的次数，默认不重试。需使用 v3.0.9 以上版本。
- **trying_interval** : 失败重试间隔时间，单位为毫秒，仅在 keep_trying 指定重试后有效。需使用 v3.0.9 以上版本。
- **childtable_from 和 childtable_to** : 指定写入子表范围，开闭区间为 [childtable_from, childtable_to) 。
- **trying_interval**：失败重试间隔时间，单位为毫秒，仅在 keep_trying 指定重试后有效。需使用 v3.0.9 以上版本。
- **childtable_from 和 childtable_to**：指定写入子表范围，开闭区间为 [childtable_from, childtable_to) 。
 
- **continue_if_fail** : 允许用户定义失败后行为。
- **continue_if_fail**：允许用户定义失败后行为。
"continue_if_fail":  "no", 失败 taosBenchmark 自动退出，默认行为。
"continue_if_fail": "yes", 失败 taosBenchmark 警告用户，并继续写入。
"continue_if_fail": "smart", 如果子表不存在失败，taosBenchmark 会建立子表并继续写入。
“continue_if_fail”：“no”，失败 taosBenchmark 自动退出，默认行为。
“continue_if_fail”：“yes”，失败 taosBenchmark 警告用户，并继续写入。
“continue_if_fail”：“smart”，如果子表不存在失败，taosBenchmark 会建立子表并继续写入。
#### 数据库相关
创建数据库时的相关参数在 json 配置文件中的 `dbinfo` 中配置，个别具体参数如下。其余参数均与 TDengine 中 `create database` 时所指定的数据库参数相对应，详见[../../taos-sql/database]
- **name** : 数据库名。
- **name**：数据库名。
- **drop** : 数据库已存在时是否删除，可选项为 "yes" 或 "no", 默认为 "yes" 。
- **drop**：数据库已存在时是否删除，可选项为 "yes" 或 "no"，默认为 “yes” 。
#### 超级表相关
创建超级表时的相关参数在 json 配置文件中的 `super_tables` 中配置，具体参数如下。
- **name**: 超级表名，必须配置，没有默认值。
- **name**：超级表名，必须配置，没有默认值。
- **child_table_exists** : 子表是否已经存在，默认值为 "no"，可选值为 "yes" 或 "no" 。
- **child_table_exists**：子表是否已经存在，默认值为 "no"，可选值为 "yes" 或 "no" 。
- **childtable_count** : 子表的数量，默认值为 10。
- **childtable_count**：子表的数量，默认值为 10。
- **childtable_prefix** : 子表名称的前缀，必选配置项，没有默认值。
- **childtable_prefix**：子表名称的前缀，必选配置项，没有默认值。
- **escape_character** : 超级表和子表名称中是否包含转义字符，默认值为 "no"，可选值为 "yes" 或 "no" 。
- **escape_character**：超级表和子表名称中是否包含转义字符，默认值为 "no"，可选值为 "yes" 或 "no" 。
- **auto_create_table** : 仅当 insert_mode 为 taosc, rest, stmt 并且 child_table_exists 为 "no" 时生效，该参数为 "yes" 表示 taosBenchmark 在插入数据时会自动创建不存在的表；为 "no" 则表示先提前建好所有表再进行插入。
- **auto_create_table**：仅当 insert_mode 为 taosc、rest、stmt 并且 child_table_exists 为 "no" 时生效，该参数为 "yes" 表示 taosBenchmark 在插入数据时会自动创建不存在的表；为 "no" 则表示先提前建好所有表再进行插入。
- **batch_create_tbl_num** : 创建子表时每批次的建表数量，默认为 10。注：实际的批数不一定与该值相同，当执行的 SQL 语句大于支持的最大长度时，会自动截断再执行，继续创建。
- **batch_create_tbl_num**：创建子表时每批次的建表数量，默认为 10。注：实际的批数不一定与该值相同，当执行的 SQL 语句大于支持的最大长度时，会自动截断再执行，继续创建。
- **data_source** : 数据的来源，默认为 taosBenchmark 随机产生，可以配置为 "rand" 和 "sample"。为 "sample" 时使用 sample_file 参数指定的文件内的数据。
- **data_source**：数据的来源，默认为 taosBenchmark 随机产生，可以配置为 "rand" 和 "sample"。为 "sample" 时使用 sample_file 参数指定的文件内的数据。
- **insert_mode** : 插入模式，可选项有 taosc, rest, stmt, sml, sml-rest, 分别对应普通写入、restful 接口写入、参数绑定接口写入、schemaless 接口写入、restful schemaless 接口写入 (由 taosAdapter 提供)。默认值为 taosc 。
- **insert_mode**：插入模式，可选项有 taosc、rest、stmt、sml、sml-rest，分别对应普通写入、restful 接口写入、参数绑定接口写入、schemaless 接口写入、restful schemaless 接口写入 (由 taosAdapter 提供)。默认值为 taosc 。
- **non_stop_mode** : 指定是否持续写入，若为 "yes" 则 insert_rows 失效，直到 Ctrl + C 停止程序，写入才会停止。默认值为 "no"，即写入指定数量的记录后停止。注：即使在持续写入模式下 insert_rows 失效，但其也必须被配置为一个非零正整数。
- **non_stop_mode**：指定是否持续写入，若为 "yes" 则 insert_rows 失效，直到 Ctrl + C 停止程序，写入才会停止。默认值为 "no"，即写入指定数量的记录后停止。注：即使在持续写入模式下 insert_rows 失效，但其也必须被配置为一个非零正整数。
- **line_protocol** : 使用行协议插入数据，仅当 insert_mode 为 sml 或 sml-rest 时生效，可选项为 line, telnet, json 。
- **line_protocol**：使用行协议插入数据，仅当 insert_mode 为 sml 或 sml-rest 时生效，可选项为 line、telnet、json 。
- **tcp_transfer** : telnet 模式下的通信协议，仅当 insert_mode 为 sml-rest 并且 line_protocol 为 telnet 时生效。如果不配置，则默认为 http 协议。
- **tcp_transfer**：telnet 模式下的通信协议，仅当 insert_mode 为 sml-rest 并且 line_protocol 为 telnet 时生效。如果不配置，则默认为 http 协议。
- **insert_rows** : 每个子表插入的记录数，默认为 0 。
- **insert_rows**：每个子表插入的记录数，默认为 0 。
- **childtable_offset** : 仅当 child_table_exists 为 yes 时生效，指定从超级表获取子表列表时的偏移量，即从第几个子表开始。
- **childtable_offset**：仅当 child_table_exists 为 yes 时生效，指定从超级表获取子表列表时的偏移量，即从第几个子表开始。
- **childtable_limit** : 仅当 child_table_exists 为 yes 时生效，指定从超级表获取子表列表的上限。
- **childtable_limit**：仅当 child_table_exists 为 yes 时生效，指定从超级表获取子表列表的上限。
- **interlace_rows** : 启用交错插入模式并同时指定向每个子表每次插入的数据行数。交错插入模式是指依次向每张子表插入由本参数所指定的行数并重复这个过程，直到所有子表的数据都插入完成。默认值为 0， 即向一张子表完成数据插入后才会向下一张子表进行数据插入。
- **interlace_rows**：启用交错插入模式并同时指定向每个子表每次插入的数据行数。交错插入模式是指依次向每张子表插入由本参数所指定的行数并重复这个过程，直到所有子表的数据都插入完成。默认值为 0，即向一张子表完成数据插入后才会向下一张子表进行数据插入。
- **insert_interval** : 指定交错插入模式的插入间隔，单位为 ms，默认值为 0。 只有当 `-B/--interlace-rows` 大于 0 时才起作用。意味着数据插入线程在为每个子表插入隔行扫描记录后，会等待该值指定的时间间隔后再进行下一轮写入。
- **insert_interval**：指定交错插入模式的插入间隔，单位为 ms，默认值为 0。只有当 `-B/--interlace-rows` 大于 0 时才起作用。意味着数据插入线程在为每个子表插入隔行扫描记录后，会等待该值指定的时间间隔后再进行下一轮写入。
- **partial_col_num** : 若该值为正数 n 时， 则仅向前 n 列写入，仅当 insert_mode 为 taosc 和 rest 时生效，如果 n 为 0 则是向全部列写入。
- **partial_col_num**：若该值为正数 n 时，则仅向前 n 列写入，仅当 insert_mode 为 taosc 和 rest 时生效，如果 n 为 0 则是向全部列写入。
- **disorder_ratio** : 指定乱序数据的百分比概率，其值域为 [0,50]。默认为 0，即没有乱序数据。
- **disorder_ratio**：指定乱序数据的百分比概率，其值域为 [0,50]。默认为 0，即没有乱序数据。
- **disorder_range** : 指定乱序数据的时间戳回退范围。所生成的乱序时间戳为非乱序情况下应该使用的时间戳减去这个范围内的一个随机值。仅在 `-O/--disorder` 指定的乱序数据百分比大于 0 时有效。
- **disorder_range**：指定乱序数据的时间戳回退范围。所生成的乱序时间戳为非乱序情况下应该使用的时间戳减去这个范围内的一个随机值。仅在 `-O/--disorder` 指定的乱序数据百分比大于 0 时有效。
- **timestamp_step** : 每个子表中插入数据的时间戳步长，单位与数据库的 `precision` 一致，默认值是 1 。
- **timestamp_step**：每个子表中插入数据的时间戳步长，单位与数据库的 `precision` 一致，默认值是 1 。
- **start_timestamp** : 每个子表的时间戳起始值，默认值是 now 。
- **start_timestamp**：每个子表的时间戳起始值，默认值是 now 。
- **sample_format** : 样本数据文件的类型，现在只支持 "csv" 。
- **sample_format**：样本数据文件的类型，现在只支持 "csv" 。
- **sample_file** : 指定 csv 格式的文件作为数据源，仅当 data_source 为 sample 时生效。若 csv 文件内的数据行数小于等于 prepared_rand，那么会循环读取 csv 文件数据直到与 prepared_rand 相同；否则则会只读取 prepared_rand 个数的行的数据。也即最终生成的数据行数为二者取小。
- **sample_file**：指定 csv 格式的文件作为数据源，仅当 data_source 为 sample 时生效。若 csv 文件内的数据行数小于等于 prepared_rand，那么会循环读取 csv 文件数据直到与 prepared_rand 相同；否则则会只读取 prepared_rand 个数的行的数据。也即最终生成的数据行数为二者取小。
- **use_sample_ts** : 仅当 data_source 为 sample 时生效，表示 sample_file 指定的 csv 文件内是否包含第一列时间戳，默认为 no。 若设置为 yes， 则使用 csv 文件第一列作为时间戳，由于同一子表时间戳不能重复，生成的数据量取决于 csv 文件内的数据行数相同，此时 insert_rows 失效。
- **use_sample_ts**：仅当 data_source 为 sample 时生效，表示 sample_file 指定的 csv 文件内是否包含第一列时间戳，默认为 no。若设置为 yes，则使用 csv 文件第一列作为时间戳，由于同一子表时间戳不能重复，生成的数据量取决于 csv 文件内的数据行数相同，此时 insert_rows 失效。
- **tags_file** : 仅当 insert_mode 为 taosc, rest 的模式下生效。 最终的 tag 的数值与 childtable_count 有关，如果 csv 文件内的 tag 数据行小于给定的子表数量，那么会循环读取 csv 文件数据直到生成 childtable_count 指定的子表数量；否则则只会读取 childtable_count 行 tag 数据。也即最终生成的子表数量为二者取小。
- **tags_file**：仅当 insert_mode 为 taosc，rest 的模式下生效。最终的 tag 的数值与 childtable_count 有关，如果 csv 文件内的 tag 数据行小于给定的子表数量，那么会循环读取 csv 文件数据直到生成 childtable_count 指定的子表数量；否则则只会读取 childtable_count 行 tag 数据。也即最终生成的子表数量为二者取小。
- **primary_key** : 指定超级表是否有复合主键，取值 1 和 0， 复合主键列只能是超级表的第二列，指定生成复合主键后要确保第二列符合复合主键的数据类型，否则会报错。
- **repeat_ts_min** : 数值类型，复合主键开启情况下指定生成相同时间戳记录的最小个数，生成相同时间戳记录的个数是在范围[repeat_ts_min, repeat_ts_max] 内的随机值, 最小值等于最大值时为固定个数。
- **repeat_ts_max** : 数值类型，复合主键开启情况下指定生成相同时间戳记录的最大个数。
- **sqls** : 字符串数组类型，指定超级表创建成功后要执行的 sql 数组，sql 中指定表名前面要带数据库名，否则会报未指定数据库错误。
- **primary_key**：指定超级表是否有复合主键，取值 1 和 0，复合主键列只能是超级表的第二列，指定生成复合主键后要确保第二列符合复合主键的数据类型，否则会报错。
- **repeat_ts_min**：数值类型，复合主键开启情况下指定生成相同时间戳记录的最小个数，生成相同时间戳记录的个数是在范围[repeat_ts_min, repeat_ts_max] 内的随机值，最小值等于最大值时为固定个数。
- **repeat_ts_max**：数值类型，复合主键开启情况下指定生成相同时间戳记录的最大个数。
- **sqls**：字符串数组类型，指定超级表创建成功后要执行的 sql 数组，sql 中指定表名前面要带数据库名，否则会报未指定数据库错误。
#### 标签列与数据列
指定超级表标签列与数据列的配置参数分别在 `super_tables` 中的 `columns` 和 `tag` 中。
- **type** : 指定列类型，可选值请参考 TDengine 支持的数据类型。
- **type**：指定列类型，可选值请参考 TDengine 支持的数据类型。
注：JSON 数据类型比较特殊，只能用于标签，当使用 JSON 类型作为 tag 时有且只能有这一个标签，此时 count 和 len 代表的意义分别是 JSON tag 内的 key-value pair 的个数和每个 KV pair 的 value 的值的长度，value 默认为 string。
- **len** : 指定该数据类型的长度，对 NCHAR，BINARY 和 JSON 数据类型有效。如果对其他数据类型配置了该参数，若为 0 ， 则代表该列始终都是以 null 值写入；如果不为 0 则被忽略。
- **len**：指定该数据类型的长度，对 NCHAR，BINARY 和 JSON 数据类型有效。如果对其他数据类型配置了该参数，若为 0，则代表该列始终都是以 null 值写入；如果不为 0 则被忽略。
- **count** : 指定该类型列连续出现的数量，例如 "count": 4096 即可生成 4096 个指定类型的列。
- **count**：指定该类型列连续出现的数量，例如 "count"：4096 即可生成 4096 个指定类型的列。
- **name** : 列的名字，若与 count 同时使用，比如 "name"："current", "count":3, 则 3 个列的名字分别为 current, current_2. current_3。
- **name**：列的名字，若与 count 同时使用，比如 "name"："current"，"count"：3，则 3 个列的名字分别为 current、current_2、current_3。
- **min** : 数据类型的 列/标签 的最小值。生成的值将大于或等于最小值。
- **min**：数据类型的 列/标签 的最小值。生成的值将大于或等于最小值。
- **max** : 数据类型的 列/标签 的最大值。生成的值将小于最大值。
- **max**：数据类型的 列/标签 的最大值。生成的值将小于最大值。
- **scalingFactor** : 浮点数精度增强因子，仅当数据类型是 float/double 时生效，有效值范围为 1 至 1000000 的正整数。用于增强生成浮点数的精度，特别是在 min 或 max 值较小的情况下。此属性按 10 的幂次增强小数点后的精度：scalingFactor 为 10 表示增强 1 位小数精度，100 表示增强 2 位，依此类推。
- **scalingFactor**：浮点数精度增强因子，仅当数据类型是 float/double 时生效，有效值范围为 1 至 1000000 的正整数。用于增强生成浮点数的精度，特别是在 min 或 max 值较小的情况下。此属性按 10 的幂次增强小数点后的精度：scalingFactor 为 10 表示增强 1 位小数精度，100 表示增强 2 位，依此类推。
- **fun** : 此列数据以函数填充，目前只支持 sin 和 cos 两函数，输入参数为时间戳换算成角度值，换算公式： 角度 x = 输入的时间列ts值 % 360。同时支持系数调节，随机波动因子调节，以固定格式的表达式展现，如 fun="10\*sin(x)+100\*random(5)" , x 表示角度，取值 0 ~ 360度，增长步长与时间列步长一致。10 表示乘的系数，100 表示加或减的系数，5 表示波动幅度在 5% 的随机范围内。目前支持的数据类型为 int, bigint, float, double 四种数据类型。注意：表达式为固定模式，不可前后颠倒。
- **fun**：此列数据以函数填充，目前只支持 sin 和 cos 两函数，输入参数为时间戳换算成角度值，换算公式：角度 x = 输入的时间列ts值 % 360。同时支持系数调节，随机波动因子调节，以固定格式的表达式展现，如 fun=“10\*sin(x)+100\*random(5)” , x 表示角度，取值 0 ~ 360度，增长步长与时间列步长一致。10 表示乘的系数，100 表示加或减的系数，5 表示波动幅度在 5% 的随机范围内。目前支持的数据类型为 int、bigint、float、double 四种数据类型。注意：表达式为固定模式，不可前后颠倒。
- **values** : nchar/binary 列/标签的值域，将从值中随机选择。
- **values**：nchar/binary 列/标签的值域，将从值中随机选择。
- **sma**: 将该列加入 SMA 中，值为 "yes" 或者 "no"，默认为 "no" 。
- **sma**：将该列加入 SMA 中，值为 "yes" 或者 "no"，默认为 "no" 。
- **encode**: 字符串类型，指定此列两级压缩中的第一级编码算法，详细参见创建超级表。
- **encode**：字符串类型，指定此列两级压缩中的第一级编码算法，详细参见创建超级表。
- **compress**: 字符串类型，指定此列两级压缩中的第二级加密算法，详细参见创建超级表。
- **compress**：字符串类型，指定此列两级压缩中的第二级加密算法，详细参见创建超级表。
- **level**: 字符串类型，指定此列两级压缩中的第二级加密算法的压缩率高低，详细参见创建超级表。
- **level**：字符串类型，指定此列两级压缩中的第二级加密算法的压缩率高低，详细参见创建超级表。
- **gen**: 字符串类型，指定此列生成数据的方式，不指定为随机，若指定为 "order", 会按自然数顺序增长。
- **gen**：字符串类型，指定此列生成数据的方式，不指定为随机，若指定为 “order”，会按自然数顺序增长。
- **fillNull**: 字符串类型，指定此列是否随机插入 NULL 值，可指定为 "true" 或 "false", 只有当 generate_row_rule 为 2 时有效。
- **fillNull**：字符串类型，指定此列是否随机插入 NULL 值，可指定为 “true” 或 "false"，只有当 generate_row_rule 为 2 时有效。
#### 写入行为相关
- **thread_count** : 插入数据的线程数量，默认为 8。
- **thread_count**：插入数据的线程数量，默认为 8。
- **thread_bind_vgroup** : 写入时 vgroup 是否和写入线程绑定，绑定后可提升写入速度, 取值为 "yes" 或 "no"，默认值为 "no", 设置为 "no" 后与原来行为一致。 当设为 "yes" 时，如果 thread_count 大于写入数据库 vgroups 数量， thread_count 自动调整为 vgroups 数量；如果 thread_count 小于 vgroups 数量，写入线程数量不做调整，一个线程写完一个 vgroup 数据后再写下一个，同时保持一个 vgroup 同时只能由一个线程写入的规则。
- **thread_bind_vgroup**：写入时 vgroup 是否和写入线程绑定，绑定后可提升写入速度，取值为 "yes" 或 "no"，默认值为 “no”，设置为 “no” 后与原来行为一致。当设为 “yes” 时，如果 thread_count 大于写入数据库 vgroups 数量，thread_count 自动调整为 vgroups 数量；如果 thread_count 小于 vgroups 数量，写入线程数量不做调整，一个线程写完一个 vgroup 数据后再写下一个，同时保持一个 vgroup 同时只能由一个线程写入的规则。
- **create_table_thread_count** : 建表的线程数量，默认为 8。
- **create_table_thread_count**：建表的线程数量，默认为 8。
- **result_file** : 结果输出文件的路径，默认值为 ./output.txt 。
- **result_file**：结果输出文件的路径，默认值为 ./output.txt 。
- **confirm_parameter_prompt** : 开关参数，要求用户在提示后确认才能继续， 可取值 "yes" or "no"。默认值为 "no" 。
- **confirm_parameter_prompt**：开关参数，要求用户在提示后确认才能继续，可取值 "yes" or "no"。默认值为 "no" 。
- **interlace_rows** : 启用交错插入模式并同时指定向每个子表每次插入的数据行数。交错插入模式是指依次向每张子表插入由本参数所指定的行数并重复这个过程，直到所有子表的数据都插入完成。默认值为 0， 即向一张子表完成数据插入后才会向下一张子表进行数据插入。
- **interlace_rows**：启用交错插入模式并同时指定向每个子表每次插入的数据行数。交错插入模式是指依次向每张子表插入由本参数所指定的行数并重复这个过程，直到所有子表的数据都插入完成。默认值为 0，即向一张子表完成数据插入后才会向下一张子表进行数据插入。
在 `super_tables` 中也可以配置该参数，若配置则以 `super_tables` 中的配置为高优先级，覆盖全局设置。
- **insert_interval** :
- **insert_interval**：
指定交错插入模式的插入间隔，单位为 ms，默认值为 0。只有当 `-B/--interlace-rows` 大于 0 时才起作用。意味着数据插入线程在为每个子表插入隔行扫描记录后，会等待该值指定的时间间隔后再进行下一轮写入。
在 `super_tables` 中也可以配置该参数，若配置则以 `super_tables` 中的配置为高优先级，覆盖全局设置。
- **num_of_records_per_req** :
- **num_of_records_per_req**：
每次向 TDengine 请求写入的数据行数，默认值为 30000 。当其设置过大时，TDengine 客户端驱动会返回相应的错误信息，此时需要调低这个参数的设置以满足写入要求。
- **prepare_rand** : 生成的随机数据中唯一值的数量。若为 1 则表示所有数据都相同。默认值为 10000 。
- **prepare_rand**：生成的随机数据中唯一值的数量。若为 1 则表示所有数据都相同。默认值为 10000 。
- **pre_load_tb_meta** ：是否提前加载子表的 meta 数据，取值为 "yes" or "no"。当子表数量非常多时，打开此选项可提高写入速度。
- **pre_load_tb_meta**：是否提前加载子表的 meta 数据，取值为 “yes” or "no"。当子表数量非常多时，打开此选项可提高写入速度。
### 查询配置参数
@ -264,38 +264,38 @@ interval 控制休眠时间，避免持续查询慢查询消耗 CPU ，单位为
查询指定表（可以指定超级表、子表或普通表）的配置参数在 `specified_table_query` 中设置。
- **mixed_query** : 查询模式
"yes" :`混合查询`
"no"(默认值) :`普通查询`
`普通查询`：`sqls` 中每个 sql 启动 `threads` 个线程查询此 sql, 执行完 `query_times` 次查询后退出，执行此 sql 的所有线程都完成后进入下一个 sql
- **mixed_query**：查询模式
“yes”：`混合查询`
"no"(默认值)：`普通查询`
`普通查询`：`sqls` 中每个 sql 启动 `threads` 个线程查询此 sql，执行完 `query_times` 次查询后退出，执行此 sql 的所有线程都完成后进入下一个 sql
`查询总次数` = `sqls` 个数 * `query_times` * `threads`
`混合查询`：`sqls` 中所有 sql 分成 `threads` 个组，每个线程执行一组，每个 sql 都需执行 `query_times` 次查询
`查询总次数` = `sqls` 个数 * `query_times`
- **query_interval** : 查询时间间隔，单位: millisecond，默认值为 0。
- **query_interval**：查询时间间隔，单位：millisecond，默认值为 0。
- **threads** : 执行查询 SQL 的线程数，默认值为 1。
- **threads**：执行查询 SQL 的线程数，默认值为 1。
- **sqls**：
- **sql**: 执行的 SQL 命令，必填。
- **result**: 保存查询结果的文件，未指定则不保存。
- **sql**：执行的 SQL 命令，必填。
- **result**：保存查询结果的文件，未指定则不保存。
#### 查询超级表
查询超级表的配置参数在 `super_table_query` 中设置。
超级表查询的线程模式与上面介绍的指定查询语句查询的 `正常查询` 模式相同，不同之处是本 `sqls` 使用所有子表填充。
- **stblname** : 指定要查询的超级表的名称，必填。
- **stblname**：指定要查询的超级表的名称，必填。
- **query_interval** : 查询时间间隔，单位是秒，默认值为 0。
- **query_interval**：查询时间间隔，单位是秒，默认值为 0。
- **threads** : 执行查询 SQL 的线程数，默认值为 1。
- **threads**：执行查询 SQL 的线程数，默认值为 1。
- **sqls**：
- **sql** : 执行的 SQL 命令，必填；对于超级表的查询 SQL，在 SQL 命令中必须保留 "xxxx"，会替换为超级下所有子表名后再执行。
- **result** : 保存查询结果的文件，未指定则不保存。
- **限制项** : sqls 下配置 sql 数组最大为 100 个。
- **sql**：执行的 SQL 命令，必填；对于超级表的查询 SQL，在 SQL 命令中必须保留 "xxxx"，会替换为超级下所有子表名后再执行。
- **result**：保存查询结果的文件，未指定则不保存。
- **限制项**：sqls 下配置 sql 数组最大为 100 个。
### 订阅配置参数
@ -303,14 +303,14 @@ interval 控制休眠时间，避免持续查询慢查询消耗 CPU ，单位为
订阅配置参数在 `tmq_info` 项下设置，参数如下：
- **concurrent** : 消费订阅的消费者数量，或称并发消费数量，默认值：1。
- **create_mode** : 创建消费者模式，可取值 sequential：顺序创建， parallel：并发同时创建，必填项，无默认值。
- **group_mode** : 生成消费者 groupId 模式，可取值 share：所有消费者只生成一个 groupId， independent：每个消费者生成一个独立的 groupId，如果 `group.id` 未设置，此项为必填项，无默认值。
- **poll_delay** : 调用 tmq_consumer_poll 传入的轮询超时时间，单位为毫秒，负数表示默认超时 1 秒。
- **enable.manual.commit** : 是否允许手动提交，可取值 true：允许手动提交，每次消费完消息后手动调用 tmq_commit_sync 完成提交， false：不进行提交，默认值: false。
- **rows_file** : 存储消费数据的文件，可以为全路径或相对路径，带文件名。实际保存的文件会在后面加上消费者序号，如 rows_file 为 result, 实际文件名为 result_1（消费者 1） result_2（消费者 2） ...
- **expect_rows** : 期望每个消费者消费的行数，数据类型，当消费达到这个数，消费会退出，不设置会一直消费。
- **topic_list** : 指定消费的 topic 列表，数组类型。topic 列表格式示例： `{"name": "topic1", "sql": "select * from test.meters;"}` ，name：指定 topic 名，sql：指定创建 topic 的 sql 语句，需保证 sql 正确，框架会自动创建出 topic。
- **concurrent**：消费订阅的消费者数量，或称并发消费数量，默认值：1。
- **create_mode**：创建消费者模式，可取值 sequential：顺序创建，parallel：并发同时创建，必填项，无默认值。
- **group_mode**：生成消费者 groupId 模式，可取值 share：所有消费者只生成一个 groupId，independent：每个消费者生成一个独立的 groupId，如果 `group.id` 未设置，此项为必填项，无默认值。
- **poll_delay**：调用 tmq_consumer_poll 传入的轮询超时时间，单位为毫秒，负数表示默认超时 1 秒。
- **enable.manual.commit**：是否允许手动提交，可取值 true：允许手动提交，每次消费完消息后手动调用 tmq_commit_sync 完成提交，false：不进行提交，默认值：false。
- **rows_file**：存储消费数据的文件，可以为全路径或相对路径，带文件名。实际保存的文件会在后面加上消费者序号，如 rows_file 为 result，实际文件名为 result_1（消费者 1） result_2（消费者 2） ...
- **expect_rows**：期望每个消费者消费的行数，数据类型，当消费达到这个数，消费会退出，不设置会一直消费。
- **topic_list**：指定消费的 topic 列表，数组类型。topic 列表格式示例：`{"name": "topic1", "sql": "select * from test.meters;"}`，name：指定 topic 名，sql：指定创建 topic 的 sql 语句，需保证 sql 正确，框架会自动创建出 topic。
以下参数透传订阅属性，参见 [订阅创建参数](../../../develop/tmq/#创建参数) 说明：
- **client.id**
@ -319,7 +319,7 @@ interval 控制休眠时间，避免持续查询慢查询消耗 CPU ，单位为
- **enable.auto.commit**
- **msg.with.table.name**
- **auto.commit.interval.ms**
- **group.id** : 若此值不指定，将由 `group_mode` 指定规则生成 groupId，若指定此值，`group_mode` 参数不再有效。
- **group.id**：若此值不指定，将由 `group_mode` 指定规则生成 groupId，若指定此值，`group_mode` 参数不再有效。
### 数据类型对照表
@ -395,23 +395,23 @@ SUCC: Spent 8.527298 (real 8.117379) seconds to insert rows: 10000000 with 8 thr
SUCC: insert delay, min: 19.6780ms, avg: 64.9390ms, p90: 94.6900ms, p95: 105.1870ms, p99: 130.6660ms, max: 157.0830ms
```
第一行写入速度统计：
- Spent: 写入总耗时，单位秒，从开始写入第一个数据开始计时到最后一条数据结束，这里表示共花了 8.527298 秒。
- real : 写入总耗时（调用引擎），此耗时已抛去测试框架准备数据时间，纯统计在引擎调用上花费的时间，示例为 8.117379 秒，8.527298 - 8.117379 = 0.409919 秒则为测试框架准备数据消耗时间
- rows : 写入总行数，为 1000 万条数据。
- threads: 写入线程数，这里是 8 个线程同时写入。
- Spent：写入总耗时，单位秒，从开始写入第一个数据开始计时到最后一条数据结束，这里表示共花了 8.527298 秒。
- real：写入总耗时（调用引擎），此耗时已抛去测试框架准备数据时间，纯统计在引擎调用上花费的时间，示例为 8.117379 秒，8.527298 - 8.117379 = 0.409919 秒则为测试框架准备数据消耗时间
- rows：写入总行数，为 1000 万条数据。
- threads：写入线程数，这里是 8 个线程同时写入。
- records/second 写入速度 = `写入总耗时`/ `写入总行数`，括号中 `real` 同前，表示纯引擎写入速度。
第二行单个写入延时统计：
- min : 写入最小延时。
- avg : 写入平时延时。
- p90 : 写入延时 p90 百分位上的延时数。
- p95 : 写入延时 p95 百分位上的延时数。
- p99 : 写入延时 p99 百分位上的延时数。
- max : 写入最大延时。
- min：写入最小延时。
- avg：写入平时延时。
- p90：写入延时 p90 百分位上的延时数。
- p95：写入延时 p95 百分位上的延时数。
- p99：写入延时 p99 百分位上的延时数。
- max：写入最大延时。
通过此系列指标，可观察到写入请求延时分布情况。
#### 查询指标
查询性能测试主要输出查询请求速度 QPS 指标, 输出格式如下：
查询性能测试主要输出查询请求速度 QPS 指标，输出格式如下：
``` bash
complete query with 3 threads and 10000 query delay avg: 0.002686s min: 0.001182s max: 0.012189s p90: 0.002977s p95: 0.003493s p99: 0.004645s SQL command: select ...
INFO: Spend 26.9530 second completed total queries: 30000, the QPS of all threads: 1113.049

6
docs/zh/14-reference/03-taos-sql/01-data-type.md
View File

@ -25,7 +25,7 @@ CREATE DATABASE db_name PRECISION 'ns';
在 TDengine 中，普通表的数据模型中可使用以下数据类型。
| # | **类型** | **Bytes** | **说明** |
| --- | :---------------: | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| --- | :---------------: | --------- | ---------------------- |
| 1 | TIMESTAMP | 8 | 时间戳。缺省精度毫秒，可支持微秒和纳秒，详细说明见上节。|
| 2 | INT | 4 | 整型，范围 [-2^31, 2^31-1] |
| 3 | INT UNSIGNED | 4 | 无符号整数，[0, 2^32-1] |
@ -59,7 +59,7 @@ CREATE DATABASE db_name PRECISION 'ns';
| 3 | POLYGON((1.0 1.0, 2.0 2.0, 1.0 1.0)) | 13+3*16 | 13+4094*16 | +16 |
- SQL 语句中的数值类型将依据是否存在小数点，或使用科学计数法表示，来判断数值类型是否为整型或者浮点型，因此在使用时要注意相应类型越界的情况。例如，9999999999999999999 会认为超过长整型的上边界而溢出，而 9999999999999999999.0 会被认为是有效的浮点数。
- VARBINARY 是一种存储二进制数据的数据类型，最大长度为 65,517 字节，标签列最大长度为 16,382 字节。可以通过sql或schemaless方式写入二进制数据（需要转换为\x开头的字符串写入），也可以通过stmt方式写入（可以直接使用二进制）。显示时通过16进制\x开头。
- VARBINARY 是一种存储二进制数据的数据类型，最大长度为 65,517 字节，标签列最大长度为 16,382 字节。可以通过sql或schemaless方式写入二进制数据（需要转换为 `\x` 开头的字符串写入），也可以通过 stmt 方式写入（可以直接使用二进制）。显示时通过16进制\x开头。
:::
@ -68,7 +68,7 @@ CREATE DATABASE db_name PRECISION 'ns';
TDengine 支持多个类型的常量，细节如下表：
| # | **语法** | **类型** | **说明** |
| --- | :-----------------------------------------------: | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
| --- | :-----------------------------------------------: | --------- | -------------------------------------------------------------------------------- |
| 1 | [\{+ \| -}]123 | BIGINT | 整型数值的字面量的类型均为 BIGINT。如果用户输入超过了 BIGINT 的表示范围，TDengine 按 BIGINT 对数值进行截断。 |
| 2 | 123.45 | DOUBLE | 浮点数值的字面量的类型均为 DOUBLE。TDengine 依据是否存在小数点，或使用科学计数法表示，来判断数值类型是否为整型或者浮点型。|
| 3 | 1.2E3 | DOUBLE | 科学计数法的字面量的类型为 DOUBLE。|

16
docs/zh/14-reference/03-taos-sql/02-database.md
View File

@ -46,13 +46,13 @@ database_option: {
### 参数说明
- VGROUPS：数据库中初始 vgroup 的数目。
- PRECISION：数据库的时间戳精度。ms 表示毫秒，us 表示微秒，ns 表示纳秒，默认 ms 毫秒。
- PRECISION：数据库的时间戳精度。ms 表示毫秒、us 表示微秒、ns 表示纳秒、默认 ms 毫秒。
- REPLICA：表示数据库副本数，取值为 1、2 或 3，默认为 1; 2 仅在企业版 3.3.0.0 及以后版本中可用。在集群中使用，副本数必须小于或等于 DNODE 的数目。且使用时存在以下限制：
- 暂不支持对双副本数据库相关 Vgroup 进行 SPLITE VGROUP 或 REDISTRIBUTE VGROUP 操作
- 单副本数据库可变更为双副本数据库，但不支持从双副本变更为其它副本数，也不支持从三副本变更为双副本
- BUFFER: 一个 VNODE 写入内存池大小，单位为 MB，默认为 256，最小为 3，最大为 16384。
- PAGES：一个 VNODE 中元数据存储引擎的缓存页个数，默认为 256，最小 64。一个 VNODE 元数据存储占用 PAGESIZE \* PAGES，默认情况下为 1MB 内存。
- PAGESIZE：一个 VNODE 中元数据存储引擎的页大小，单位为 KB，默认为 4 KB。范围为 1 到 16384，即 1 KB 到 16 MB。
- BUFFER：一个 vnode 写入内存池大小，单位为 MB，默认为 256，最小为 3，最大为 16384。
- PAGES：一个 vnode 中元数据存储引擎的缓存页个数，默认为 256，最小 64。一个 vnode 元数据存储占用 PAGESIZE \* PAGES，默认情况下为 1MB 内存。
- PAGESIZE：一个 vnode 中元数据存储引擎的页大小，单位为 KB，默认为 4 KB。范围为 1 到 16384，即 1 KB 到 16 MB。
- CACHEMODEL：表示是否在内存中缓存子表的最近数据。默认为 none。
- none：表示不缓存。
- last_row：表示缓存子表最近一行数据。这将显著改善 LAST_ROW 函数的性能表现。
@ -76,17 +76,17 @@ database_option: {
- 1：表示只可以创建一张超级表。
- TABLE_PREFIX：当其为正值时，在决定把一个表分配到哪个 vgroup 时要忽略表名中指定长度的前缀；当其为负值时，在决定把一个表分配到哪个 vgroup 时只使用表名中指定长度的前缀；例如，假定表名为 "v30001"，当 TSDB_PREFIX = 2 时 使用 "0001" 来决定分配到哪个 vgroup ，当 TSDB_PREFIX = -2 时使用 "v3" 来决定分配到哪个 vgroup
- TABLE_SUFFIX：当其为正值时，在决定把一个表分配到哪个 vgroup 时要忽略表名中指定长度的后缀；当其为负值时，在决定把一个表分配到哪个 vgroup 时只使用表名中指定长度的后缀；例如，假定表名为 "v30001"，当 TSDB_SUFFIX = 2 时 使用 "v300" 来决定分配到哪个 vgroup ，当 TSDB_SUFFIX = -2 时使用 "01" 来决定分配到哪个 vgroup。
- TSDB_PAGESIZE：一个 VNODE 中时序数据存储引擎的页大小，单位为 KB，默认为 4 KB。范围为 1 到 16384，即 1 KB到 16 MB。
- DNODES：指定 VNODE 所在的 DNODE 列表，如 '1,2,3'，以逗号区分且字符间不能有空格，仅企业版支持。
- TSDB_PAGESIZE：一个 vnode 中时序数据存储引擎的页大小，单位为 KB，默认为 4 KB。范围为 1 到 16384，即 1 KB到 16 MB。
- DNODES：指定 vnode 所在的 DNODE 列表，如 '1,2,3'，以逗号区分且字符间不能有空格，仅企业版支持。
- WAL_LEVEL：WAL 级别，默认为 1。
- 1：写 WAL，但不执行 fsync。
- 2：写 WAL，而且执行 fsync。
- WAL_FSYNC_PERIOD：当 WAL_LEVEL 参数设置为 2 时，用于设置落盘的周期。默认为 3000，单位毫秒。最小为 0，表示每次写入立即落盘；最大为 180000，即三分钟。
- WAL_RETENTION_PERIOD: 为了数据订阅消费，需要 WAL 日志文件额外保留的最大时长策略。WAL 日志清理，不受订阅客户端消费状态影响。单位为 s。默认为 3600，表示在 WAL 保留最近 3600 秒的数据，请根据数据订阅的需要修改这个参数为适当值。
- WAL_RETENTION_PERIOD：为了数据订阅消费，需要 WAL 日志文件额外保留的最大时长策略。WAL 日志清理，不受订阅客户端消费状态影响。单位为 s。默认为 3600，表示在 WAL 保留最近 3600 秒的数据，请根据数据订阅的需要修改这个参数为适当值。
- WAL_RETENTION_SIZE：为了数据订阅消费，需要 WAL 日志文件额外保留的最大累计大小策略。单位为 KB。默认为 0，表示累计大小无上限。
- COMPACT_INTERVAL：自动 compact 触发周期（从 1970-01-01T00:00:00Z 开始切分的时间周期)。取值范围：0 或 [10m, keep2]，单位：m（分钟），h（小时），d（天）。不加时间单位默认单位为天，默认值为 0，即不触发自动 compact 功能。如果 db 中有未完成的 compact 任务，不重复下发 compact 任务。仅企业版 3.3.5.0 版本开始支持。
- COMPACT_TIME_RANGE：自动 compact 任务触发的 compact 时间范围，取值范围：[-keep2, -duration]，单位：m（分钟），h（小时），d（天）。不加时间单位时默认单位为天，默认值为 [0, 0]。取默认值 [0, 0] 时，如果 COMPACT_INTERVAL 大于 0，会按照 [-keep2, -duration] 下发自动 compact。因此，要关闭自动 compact 功能，需要将 COMPACT_INTERVAL 设置为 0。仅企业版 3.3.5.0 版本开始支持。
- COMPACT_TIME_OFFSET：自动 compact 任务触发的 compact 时间相对本地时间的偏移量。取值范围：[0,23]，单位: h（小时），默认值为 0。以 UTC 0 时区为例，如果 COMPACT_INTERVAL 为 1d，当 COMPACT_TIME_OFFSET 为 0 时，在每天 0 点下发自动 compact，如果 COMPACT_TIME_OFFSET 为 2，在每天 2 点下发自动 compact。仅企业版 3.3.5.0 版本开始支持。
- COMPACT_TIME_OFFSET：自动 compact 任务触发的 compact 时间相对本地时间的偏移量。取值范围：[0, 23]，单位：h（小时），默认值为 0。以 UTC 0 时区为例，如果 COMPACT_INTERVAL 为 1d，当 COMPACT_TIME_OFFSET 为 0 时，在每天 0 点下发自动 compact，如果 COMPACT_TIME_OFFSET 为 2，在每天 2 点下发自动 compact。仅企业版 3.3.5.0 版本开始支持。
-
### 创建数据库示例

18
docs/zh/14-reference/03-taos-sql/06-select.md
View File

@ -99,10 +99,10 @@ Hints 是用户控制单个语句查询优化的一种手段，当 Hint 不适
| :-----------: | -------------- | -------------------------- | -----------------------------|
| BATCH_SCAN | 无 | 采用批量读表的方式 | 超级表 JOIN 语句 |
| NO_BATCH_SCAN | 无 | 采用顺序读表的方式 | 超级表 JOIN 语句 |
| SORT_FOR_GROUP| 无 | 采用sort方式进行分组, 与PARTITION_FIRST冲突 | partition by 列表有普通列时 |
| PARTITION_FIRST| 无 | 在聚合之前使用PARTITION计算分组, 与SORT_FOR_GROUP冲突 | partition by 列表有普通列时 |
| PARA_TABLES_SORT| 无 | 超级表的数据按时间戳排序时, 不使用临时磁盘空间, 只使用内存。当子表数量多, 行长比较大时候, 会使用大量内存, 可能发生OOM | 超级表的数据按时间戳排序时 |
| SMALLDATA_TS_SORT| 无 | 超级表的数据按时间戳排序时, 查询列长度大于等于256, 但是行数不多, 使用这个提示, 可以提高性能 | 超级表的数据按时间戳排序时 |
| SORT_FOR_GROUP| 无 | 采用 sort 方式进行分组，与 PARTITION_FIRST 冲突 | partition by 列表有普通列时 |
| PARTITION_FIRST| 无 | 在聚合之前使用 PARTITION 计算分组，与 SORT_FOR_GROUP 冲突 | partition by 列表有普通列时 |
| PARA_TABLES_SORT| 无 | 超级表的数据按时间戳排序时，不使用临时磁盘空间，只使用内存。当子表数量多，行长比较大时候，会使用大量内存，可能发生 OOM | 超级表的数据按时间戳排序时 |
| SMALLDATA_TS_SORT| 无 | 超级表的数据按时间戳排序时，查询列长度大于等于 256，但是行数不多，使用这个提示，可以提高性能 | 超级表的数据按时间戳排序时 |
| SKIP_TSMA | 无 | 用于显示的禁用 TSMA 查询优化 | 带 Agg 函数的查询语句 |
举例：
@ -321,13 +321,13 @@ NULLS 语法用来指定 NULL 值在排序中输出的位置。NULLS LAST 是升
## LIMIT
LIMIT 控制输出条数，OFFSET 指定从第几条之后开始输出。LIMIT/OFFSET 对结果集的执行顺序在 ORDER BY 之后。LIMIT 5 OFFSET 2 可以简写为 LIMIT 2, 5，都输出第 3 行到第 7 行数据。
LIMIT 控制输出条数，OFFSET 指定从第几条之后开始输出。LIMIT/OFFSET 对结果集的执行顺序在 ORDER BY 之后。`LIMIT 5 OFFSET 2` 可以简写为 `LIMIT 2, 5`，都输出第 3 行到第 7 行数据。
在有 PARTITION BY/GROUP BY 子句时，LIMIT 控制的是每个切分的分片中的输出，而不是总的结果集输出。
## SLIMIT
SLIMIT 和 PARTITION BY/GROUP BY 子句一起使用，用来控制输出的分片的数量。SLIMIT 5 SOFFSET 2 可以简写为 SLIMIT 2, 5，都表示输出第 3 个到第 7 个分片。
SLIMIT 和 PARTITION BY/GROUP BY 子句一起使用，用来控制输出的分片的数量。`SLIMIT 5 SOFFSET 2` 可以简写为 SLIMIT `2, 5`，都表示输出第 3 个到第 7 个分片。
需要注意，如果有 ORDER BY 子句，则输出只有一个分片。
@ -484,8 +484,8 @@ SELECT ... FROM (SELECT ... FROM ...) ...;
- 内层查询的 ORDER BY 子句一般没有意义，建议避免这样的写法以免无谓的资源消耗。
- 与非嵌套的查询语句相比，外层查询所能支持的功能特性存在如下限制：
- 计算函数部分：
- 如果内层查询的结果数据未提供时间戳，那么计算过程隐式依赖时间戳的函数在外层会无法正常工作。例如：INTERP, DERIVATIVE, IRATE, LAST_ROW, FIRST, LAST, TWA, STATEDURATION, TAIL, UNIQUE。
- 如果内层查询的结果数据不是按时间戳有序，那么计算过程依赖数据按时间有序的函数在外层会无法正常工作。例如：LEASTSQUARES, ELAPSED, INTERP, DERIVATIVE, IRATE, TWA, DIFF, STATECOUNT, STATEDURATION, CSUM, MAVG, TAIL, UNIQUE。
- 如果内层查询的结果数据未提供时间戳，那么计算过程隐式依赖时间戳的函数在外层会无法正常工作。例如：INTERP、DERIVATIVE、IRATE、LAST_ROW、FIRST、LAST、TWA、STATEDURATION、TAIL、UNIQUE。
- 如果内层查询的结果数据不是按时间戳有序，那么计算过程依赖数据按时间有序的函数在外层会无法正常工作。例如：LEASTSQUARES、ELAPSED、INTERP、DERIVATIVE、IRATE、TWA、DIFF、STATECOUNT、STATEDURATION、CSUM、MAVG、TAIL、UNIQUE。
- 计算过程需要两遍扫描的函数，在外层查询中无法正常工作。例如：此类函数包括：PERCENTILE。
:::
@ -520,7 +520,7 @@ SELECT * FROM tb1 WHERE ts >= NOW - 1h;
SELECT * FROM tb1 WHERE ts > '2018-06-01 08:00:00.000' AND ts <= '2018-06-02 08:00:00.000' AND col3 LIKE '%nny' ORDER BY ts DESC;
```
查询 col1 与 col2 的和，并取名 complex, 时间大于 2018-06-01 08:00:00.000, col2 大于 1.2，结果输出仅仅 10 条记录，从第 5 条开始：
查询 col1 与 col2 的和，并取名 complex，时间大于 2018-06-01 08:00:00.000，col2 大于 1.2，结果输出仅仅 10 条记录，从第 5 条开始：
```
SELECT (col1 + col2) AS 'complex' FROM tb1 WHERE ts > '2018-06-01 08:00:00.000' AND col2 > 1.2 LIMIT 10 OFFSET 5;

4
docs/zh/14-reference/03-taos-sql/07-tag-index.md
View File

@ -41,7 +41,7 @@ SHOW INDEXES FROM [db_name.]tbl_name;
## 使用说明
1. 索引使用得当能够提升数据过滤的效率，目前支持的过滤算子有 `=`, `>`, `>=`, `<`, `<=`。如果查询过滤条件中使用了这些算子，则索引能够明显提升查询效率。但如果查询过滤条件中使用的是其它算子，则索引起不到作用，查询效率没有变化。未来会逐步添加更多的算子。
1. 索引使用得当能够提升数据过滤的效率，目前支持的过滤算子有 `=`、`>`、`>=`、`<`、`<=`。如果查询过滤条件中使用了这些算子，则索引能够明显提升查询效率。但如果查询过滤条件中使用的是其它算子，则索引起不到作用，查询效率没有变化。未来会逐步添加更多的算子。
2. 针对一个 tag 列只能建立一个索引，如果重复创建索引则会报错。
@ -55,4 +55,4 @@ SHOW INDEXES FROM [db_name.]tbl_name;
7. 如果某个 tag 列的唯一值较少时，不建议对其建立索引，这种情况下收效甚微。
8. 新建立的超级表，会给第一列tag，随机生成一个indexNewName, 生成规则是:tag0的name + 23个byte, 在系统表可以查,也可以按需要drop,行为和其他列tag 的索引一样
8. 新建立的超级表，会给第一列 tag，随机生成一个indexNewName，生成规则是：tag0的name + 23个byte，在系统表可以查,也可以按需要drop，行为和其他列 tag 的索引一样

8
docs/zh/14-reference/03-taos-sql/08-delete-data.mdx
View File

@ -14,19 +14,19 @@ title: "删除数据"
DELETE FROM [ db_name. ] tb_name [WHERE condition];
```
**功能：** 删除指定表或超级表中的数据记录
**功能**：删除指定表或超级表中的数据记录
**参数：**
**参数**：
- `db_name` ：可选参数，指定要删除表所在的数据库名，不填写则在当前数据库中
- `tb_name` ：必填参数，指定要删除数据的表名，可以是普通表、子表，也可以是超级表。
- `condition`：可选参数，指定删除数据的过滤条件，不指定过滤条件则为表中所有数据，请慎重使用。特别说明，这里的 where 条件中只支持对第一列时间列的过滤。
**特别说明：**
**特别说明**：
数据删除后不可恢复，请慎重使用。为了确保删除的数据确实是自己要删除的，建议可以先使用 `select` 语句加 `where` 后的删除条件查看要删除的数据内容，确认无误后再执行 `delete` 命令。
**示例：**
**示例**：
`meters` 是一个超级表，`groupid` 是 int 类型的 tag 列，现在要删除 `meters` 表中时间小于 2021-10-01 10:40:00.100 的所有数据，sql 如下：

167
docs/zh/14-reference/03-taos-sql/10-function.md
View File

@ -193,7 +193,7 @@ ROUND(expr[, digits])
- `digits` 小于零表示丢掉小数位，并将数字四舍五入到小数点左侧 `digits` 位。若小数点左侧的位数小于 `digits`位，返回 0。
- 由于暂未支持 DECIMAL 类型，所以该函数会用 DOUBLE 和 FLOAT 来表示包含小数的结果，但是 DOUBLE 和 FLOAT 是有精度上限的，当位数太多时使用该函数可能没有意义。
- 只能与普通列，选择（Selection）、投影（Projection）函数一起使用，不能与聚合（Aggregation）函数一起使用。
- `digits` 从 3.3.3.0 版本开始支持。
- `digits` 从 v3.3.3.0 开始支持。
**举例**：
```sql
@ -269,7 +269,7 @@ PI()
**功能说明**：返回圆周率 π 的值。
**使用说明**：ver-3.3.3.0
**版本**：v3.3.3.0
**返回结果类型**：DOUBLE。
@ -298,7 +298,7 @@ TRUNCATE(expr, digits)
**功能说明**：获得指定字段按照指定位数截断的值。
**使用说明**：ver-3.3.3.0
**版本**：v3.3.3.0
**返回结果类型**：与 `expr` 字段的原始数据类型一致。
@ -338,7 +338,7 @@ EXP(expr)
```
**功能说明**：返回 e（自然对数的底）的指定乘方后的值。
**使用说明**：ver-3.3.3.0
**版本**：v3.3.3.0
**返回结果类型**：DOUBLE。
@ -367,7 +367,7 @@ LN(expr)
**功能说明**：返回指定参数的自然对数。
**使用说明**：ver-3.3.3.0
**版本**：v3.3.3.0
**返回结果类型**：DOUBLE。
@ -397,7 +397,7 @@ MOD(expr1, expr2)
**功能说明**：计算 expr1 % expr2 的结果。
**使用说明**：ver-3.3.3.0
**版本**：v3.3.3.0
**返回结果类型**：DOUBLE。
@ -432,7 +432,7 @@ RAND([seed])
**功能说明**：返回一个从0到1均匀分布的随机数。
**使用说明**：ver-3.3.3.0
**版本**：v3.3.3.0
**返回结果类型**：DOUBLE。
@ -477,7 +477,7 @@ SIGN(expr)
**功能说明**：返回指定参数的符号。
**使用说明**：ver-3.3.3.0
**版本**：v3.3.3.0
**返回结果类型**：与指定字段的原始数据类型一致。
@ -519,7 +519,7 @@ DEGREES(expr)
**功能说明**：计算指定参数由弧度值转为角度后的值。
**使用说明**：ver-3.3.3.0
**版本**：v3.3.3.0
**返回结果类型**：DOUBLE。
@ -549,7 +549,7 @@ RADIANS(expr)
**功能说明**：计算指定参数由角度值转为弧度后的值。
**使用说明**：ver-3.3.3.0
**版本**：v3.3.3.0
**返回结果类型**：DOUBLE。
@ -721,7 +721,7 @@ TRIM([remstr FROM] expr)
**功能说明**：返回去掉了所有 remstr 前缀或后缀的字符串 epxr。
**使用说明**：ver-3.3.3.0
**版本**：v3.3.3.0
**返回结果类型**：与输入字段 epxr 的原始类型相同。
@ -794,8 +794,8 @@ SUBSTRING/SUBSTR(expr FROM pos [FOR len])
- 若 `len` 小于 1，返回空串。
- `pos` 是 1-base 的，若 `pos` 为 0，返回空串。
- 若 `pos` + `len` 大于 `len(expr)`，返回从 `pos` 开始到字符串结尾的子串，等同于执行 `substring(expr, pos)`。
- `SUBSTRING` 函数等价于 `SUBSTR`，从 3.3.3.0 版本开始支持。
- `SUBSTRING/SUBSTR(expr FROM pos [FOR len])` 语法从 3.3.3.0 版本开始支持。
- `SUBSTRING` 函数等价于 `SUBSTR`，从 v3.3.3.0 开始支持。
- `SUBSTRING/SUBSTR(expr FROM pos [FOR len])` 语法从 v3.3.3.0 开始支持。
**举例**：
```sql
@ -832,12 +832,12 @@ SUBSTRING_INDEX(expr, delim, count)
**功能说明**：返回字符串 `expr` 在出现指定次数分隔符的位置截取的子串。
**使用说明**：ver-3.3.3.0
**版本**：v3.3.3.0
**返回结果类型**：与输入字段 `expr` 的原始类型相同。
**适用数据类型**：
- `expr`：VARCHA、 NCHAR。
- `expr`：VARCHAR、NCHAR。
- `delim`：VARCHAR、NCHAR。
- `count`：INTEGER。
@ -887,18 +887,18 @@ CHAR(expr1 [, expr2] [, epxr3] ...)
**功能说明**：将输入参数当作整数，并返回这些整数在 ASCII 编码中对应的字符。
**使用说明**：ver-3.3.3.0
**版本**：v3.3.3.0
**返回结果类型**：VARCHAR。
**适用数据类型**：整数类型,VARCHAR,NCHAR。
**适用数据类型**：整数类型,VARCHAR、NCHAR。
**嵌套子查询支持**：适用于内层查询和外层查询。
**适用于**：表和超级表。
**使用说明**：
- 输入的值超过 255 会被转化成多字节的结果，如 `CHAR(256)` 等同于 `CHAR(1,0)`，`CHAR(256 * 256)` 等同于 `CHAR(1,0,0)`。
- 输入的值超过 255 会被转化成多字节的结果，如 `CHAR(256)` 等同于 `CHAR(1,0)`、`CHAR(256 * 256)` 等同于 `CHAR(1,0,0)`。
- 输入参数的 NULL 值会被跳过。
- 输入参数若为字符串类型，会将其转换为数值类型处理。
- 若输入的参数对应的字符为不可打印字符，返回值中仍有该参数对应的字符，但是可能无法显示出来。
@ -934,7 +934,7 @@ ASCII(expr)
**功能说明**：返回字符串第一个字符的 ASCII 码。
**使用说明**：ver-3.3.3.0
**版本**：v3.3.3.0
**返回结果数据类型**：BIGINT。
@ -963,7 +963,7 @@ POSITION(expr1 IN expr2)
**功能说明**：计算字符串 `expr1` 在字符串 `expr2` 中的位置。
**使用说明**：ver-3.3.3.0
**版本**：v3.3.3.0
**返回结果类型**：BIGINT。
@ -1007,7 +1007,7 @@ REPLACE(expr, from_str, to_str)
```
**功能说明**：将字符串中的 `from_str` 全部替换为 `to_str`。
**使用说明**：ver-3.3.3.0
**版本**：v3.3.3.0
**返回结果类型**：与输入字段 `expr` 的原始类型相同。
@ -1039,7 +1039,7 @@ REPEAT(expr, count)
```
**功能说明**：返回将字符串重复指定次数得到的字符串。
**使用说明**：ver-3.3.3.0
**版本**：v3.3.3.0
**返回结果类型**：与输入字段 `expr` 的原始类型相同。
@ -1113,8 +1113,8 @@ TO_ISO8601(expr [, timezone])
**使用说明**：
- timezone 参数允许输入的时区格式为：[z/Z, +/-hhmm, +/-hh, +/-hh:mm]。例如 TO_ISO8601(1, "+00:00")。
- 输入时间戳的精度由所查询表的精度确定，若未指定表，则精度为毫秒。
- timezone 参数允许输入的时区格式为：[z/Z, +/-hhmm, +/-hh, +/-hh:mm]。例如，TO_ISO8601(1, "+00:00")。
- 输入时间戳的精度由所查询表的精度确定，若未指定表，则精度为毫秒.
#### TO_JSON
@ -1169,7 +1169,7 @@ TO_CHAR(ts, format_str_literal)
**功能说明**：将 timestamp 类型按照指定格式转换为字符串。
**使用说明**：ver-3.2.2.0
**使用说明**：vv3.2.2.0
**返回结果数据类型**：VARCHAR。
@ -1192,9 +1192,9 @@ TO_CHAR(ts, format_str_literal)
| MONTH | 月，全大写 | 2023-JANUARY-01 |
| Month | 月，首字母大写 | 2023-January-01 |
| month | 月，全小写 | 2023-january-01 |
| MON | 月，缩写，全大写(三个字符) | JAN, SEP |
| Mon | 月，缩写，首字母大写 | Jan, Sep |
| mon | 月，缩写，全小写 | jan, sep |
| MON | 月，缩写，全大写(三个字符) | JAN、SEP |
| Mon | 月，缩写，首字母大写 | Jan、Sep |
| mon | 月，缩写，全小写 | jan、sep |
| MM,mm | 月，数字 01-12 | 2023-01-01 |
| DD,dd | 月日，01-31 | |
| DAY | 周日，全大写 | MONDAY |
@ -1293,10 +1293,10 @@ TIMEDIFF(expr1, expr2 [, time_unit])
**返回结果类型**：BIGINT。
**适用数据类型**：
- `expr1`：表示时间戳的 BIGIN、 TIMESTAMP 类型，或符合 ISO8601/RFC3339 标准的日期时间格式的 VARCHAR、NCHAR 类型。
- `expr1`：表示时间戳的 BIGINT、TIMESTAMP 类型，或符合 ISO8601/RFC3339 标准的日期时间格式的 VARCHAR、NCHAR 类型。
- `expr2`：表示时间戳的 BIGINT、TIMESTAMP 类型，或符合 ISO8601/RFC3339 标准的日期时间格式的 VARCHAR、NCHAR 类型。
- `time_unit`：见使用说明。
- 3.3.3.0 版本之前该函数结果为时间戳 `expr1` 和 `expr2` 的差值的绝对值，结果为正数。
- v3.3.3.0 之前该函数结果为时间戳 `expr1` 和 `expr2` 的差值的绝对值，结果为正数。
**嵌套子查询支持**：适用于内层查询和外层查询。
@ -1352,7 +1352,8 @@ use_current_timezone: {
例如客户端所配置时区为 UTC+0800，则 TIMETRUNCATE('2020-01-01 23:00:00', 1d, 0) 返回结果为东八区时间 '2020-01-01 08:00:00'。
而使用 TIMETRUNCATE('2020-01-01 23:00:00', 1d, 1) 时，返回结果为东八区时间 '2020-01-01 00:00:00'。
当不指定 use_current_timezone 时，use_current_timezone 默认值为 1。
- 当将时间值截断到一周（1w）时，timetruncate 的计算是基于 Unix 时间戳（1970年1月1日00:00:00 UTC）进行的。Unix 时间戳始于星期四，因此所有截断后的日期都是星期四。
- 当将时间值截断到一周（1w）时，timetruncate 的计算是基于 Unix 时间戳（1970年1月1日00:00:00 UTC）进行的。Unix 时间戳始于星期四，
因此所有截断后的日期都是星期四。
#### TIMEZONE
@ -1396,7 +1397,7 @@ WEEK(expr [, mode])
```
**功能说明**：返回输入日期的周数。
**使用说明**：ver-3.3.3.0
**版本**：v3.3.3.0
**返回结果类型**：BIGINT。
@ -1410,7 +1411,7 @@ WEEK(expr [, mode])
**使用说明**：
- 若 `expr` 为 NULL，返回 NULL。
- 输入时间戳的精度由所查询表的精度确定，若未指定表，则精度为毫秒。
- 输入时间戳的精度由所查询表的精度确定，若未指定表，则精度为毫秒.
- `mode` 用来指定一周是从周日开始还是周一开始，以及指定返回值范围是 1 - 53 还是 0 - 53。下表详细描述不同的 mode 对应的计算方法：
| Mode | 每周的第一天 | 返回值范围 | 第 1 周的计算方法 |
@ -1426,9 +1427,9 @@ WEEK(expr [, mode])
- 当返回值范围为 0 - 53 时，第 1 周之前的日期为第 0 周。
- 当返回值范围为 1 - 53 时，第 1 周之前的日期为上一年的最后一周。
- 以`2000-01-01`为例，
- 在 `mode=0`时返回值为 `0`，因为该年第一个周日为 `2000-01-02`，从 `2000-01-02` 起才是第一周，所以 `2000-01-01`为第 0 周，返回 0。
- 在 `mode=0` 时返回值为 `0`，因为该年第一个周日为 `2000-01-02`，从 `2000-01-02` 起才是第 1 周，所以 `2000-01-01` 为第 0 周，返回 0。
- 在 `mode=1` 时返回值为 `0`，因为 `2000-01-01` 所在的周只有两天，分别是 `2000-01-01(周六)` 和 `2000-01-02(周日)`，所以 `2000-01-03` 起才是第一周，`2000-01-01`为第 0 周，返回 0。
- 在 `mode=2`时返回值为 `52`，因为从 `2000-01-02` 起才是第一周，并且返回值范围为 1-53，所以 `2000-01-01` 算做上一年的最后一周，即 1999 年的第 52 周，返回 52。
- 在 `mode=2` 时返回值为 `52`，因为从 `2000-01-02` 起才是第 1 周，并且返回值范围为 1-53，所以 `2000-01-01` 算做上一年的最后一周，即 1999 年的第 52 周，返回 52。
**举例**：
```sql
@ -1459,7 +1460,7 @@ WEEKOFYEAR(expr)
```
**功能说明**：返回输入日期的周数。
**使用说明**：ver-3.3.3.0
**版本**：v3.3.3.0
**返回结果类型**：BIGINT。
@ -1472,7 +1473,7 @@ WEEKOFYEAR(expr)
**使用说明**：
- 等同于`WEEK(expr, 3)`，即在每周第一天是周一，返回值范围为 1-53，第一个包含四天及以上的周为第 1 周的条件下判断输入日期的周数。
- 若 `expr` 为 NULL，返回 NULL。
- 输入时间戳的精度由所查询表的精度确定，若未指定表，则精度为毫秒。
- 输入时间戳的精度由所查询表的精度确定，未未指定表，则精度为毫秒。
**举例**：
```sql
@ -1488,11 +1489,11 @@ WEEKDAY(expr)
```
**功能说明**：返回输入日期是周几。
**使用说明**：ver-3.3.3.0
**版本**：v3.3.3.0
**返回结果类型**：BIGINT。
**适用数据类型**：表示 表示时间戳的 BIGINT、TIMESTAMP 类型，或符合 ISO8601/RFC3339 标准的日期时间格式的 VARCHAR、NCHAR 类型。
**适用数据类型**：表示时间戳的 BIGINT、TIMESTAMP 类型，或符合 ISO8601/RFC3339 标准的日期时间格式的 VARCHAR、NCHAR 类型。
**嵌套子查询支持**：适用于内层查询和外层查询。
@ -1517,7 +1518,7 @@ DAYOFWEEK(expr)
```
**功能说明**：返回输入日期是周几。
**使用说明**：ver-3.3.3.0
**版本**：v3.3.3.0
**返回结果类型**：BIGINT。
@ -1569,7 +1570,7 @@ algo_type: {
**说明**：
- p 值范围是 [0,100]，当为 0 时等同 于MIN，为 100 时等同于 MAX。
- algo_type 取值为 "default" 或 "t-digest"。输入为 "default" 时函数使用基于直方图算法进行计算。输入为 "t-digest" 时使用 t-digest 算法计算分位数的近似结果。如果不指定 algo_type 则使用 "default" 算法。
- "t-digest" 算法的近似结果对于输入数据顺序敏感，对超级表查询时不同的输入排序结果可能会有微小的误差。
- t-digest 算法的近似结果对于输入数据顺序敏感，对超级表查询时不同的输入排序结果可能会有微小的误差。
### AVG
@ -1628,7 +1629,7 @@ ELAPSED(ts_primary_key [, time_unit])
- order by asc/desc 不影响差值的计算结果。
- 对于超级表，需要和 group by tbname 子句组合使用，不可以直接使用。
- 对于普通表，不支持和 group by 子句组合使用。
- 对于嵌套查询，仅当内层查询会输出隐式时间戳列时有效。例如 select elapsed(ts) from (select diff(value) from sub1) 语句，diff 函数会让内层查询输出隐式时间戳列，此为主键列，可以用于 elapsed 函数的第一个参数。相反，例如 select elapsed(ts) from (select * from sub1) 语句，ts 列输出到外层时已经没有了主键列的含义，无法使用 elapsed 函数。此外，elapsed 函数作为一个与时间线强依赖的函数，形如 select elapsed(ts) from (select diff(value) from st group by tbname)尽 管会返回一条计算结果，但并无实际意义，这种用法后续也将被限制。
- 对于嵌套查询，仅当内层查询会输出隐式时间戳列时有效。例如 `select elapsed(ts) from (select diff(value) from sub1)` 语句，diff 函数会让内层查询输出隐式时间戳列，此为主键列，可以用于 elapsed 函数的第一个参数。相反，例如 `select elapsed(ts) from (select * from sub1)` 语句，ts 列输出到外层时已经没有了主键列的含义，无法使用 elapsed 函数。此外，elapsed 函数作为一个与时间线强依赖的函数，形如 `select elapsed(ts) from (select diff(value) from st group by tbname)` 尽管会返回一条计算结果，但并无实际意义，这种用法后续也将被限制。
- 不支持与 leastsquares、diff、derivative、top、bottom、last_row、interp 等函数混合使用。
@ -1677,7 +1678,7 @@ STDDEV/STDDEV_POP(expr)
**适用于**：表和超级表。
**说明**：
- `STDDEV_POP` 函数等价于 `STDDEV` 函数，从 3.3.3.0 版本开始支持。
- `STDDEV_POP` 函数等价于 `STDDEV` 函数，从 v3.3.3.0 开始支持。
**举例**：
```sql
@ -1702,7 +1703,7 @@ VAR_POP(expr)
**功能说明**：统计表中某列的总体方差。
**使用说明**：ver-3.3.3.0
**版本**：v3.3.3.0
**返回数据类型**：DOUBLE。
@ -1710,7 +1711,7 @@ VAR_POP(expr)
**适用于**：表和超级表。
**举例**:
**举例**：
```sql
taos> select id from test_var;
id |
@ -1749,7 +1750,7 @@ HYPERLOGLOG(expr)
**功能说明**：
- 采用 hyperloglog 算法，返回某列的基数。该算法在数据量很大的情况下，可以明显降低内存的占用，求出来的基数是个估算值，标准误差（标准误差是多次实验，每次的平均数的标准差，不是与真实结果的误差）为 0.81%。
- 在数据量较少的时候该算法不是很准确，可以使用 select count(data) from (select unique(col) as data from table) 的方法。
- 在数据量较少的时候该算法不是很准确，可以使用 `select count(data) from (select unique(col) as data from table)` 的方法。
**返回结果类型**：INTEGER。
@ -1779,7 +1780,7 @@ HISTOGRAM(expr，bin_type, bin_description, normalized)
用户指定 bin 的具体数值。
- "linear_bin": "\{"start": 0.0, "width": 5.0, "count": 5, "infinity": true}"
"start" 表示数据起始点，"width" 表示每次 bin 偏移量, "count" 为 bin 的总数，"infinity" 表示是否添加（-inf, inf）作为区间起点和终点，
"start" 表示数据起始点，"width" 表示每次 bin 偏移量，"count" 为 bin 的总数，"infinity" 表示是否添加（-inf, inf）作为区间起点和终点，
生成区间为[-inf, 0.0, 5.0, 10.0, 15.0, 20.0, +inf]。
- "log_bin": "\{"start":1.0, "factor": 2.0, "count": 5, "infinity": true}"
@ -1806,7 +1807,7 @@ PERCENTILE(expr, p [, p1] ... )
- *P* 值取值范围 0≤*P*≤100，为 0 的时候等同于 MIN，为 100 的时候等同于 MAX;
- 同时计算针对同一列的多个分位数时，建议使用一个 PERCENTILE 函数和多个参数的方式，能很大程度上降低查询的响应时间。
比如，使用查询SELECT percentile(col, 90, 95, 99) FROM table，性能会优于SELECT percentile(col, 90), percentile(col, 95), percentile(col, 99) from table。
比如，使用查询 `SELECT percentile(col, 90, 95, 99) FROM table`，性能会优于 `SELECT percentile(col, 90), percentile(col, 95), percentile(col, 99) from table`。
## 选择函数
@ -1849,8 +1850,8 @@ FIRST(expr)
**使用说明**：
- 如果要返回各个列的首个（时间戳最小）非 NULL 值，可以使用 FIRST(\*)；查询超级表，且multiResultFunctionStarReturnTags设置为 0 (默认值) 时，FIRST(\*) 只返回超级表的普通列；设置为 1 时，返回超级表的普通列和标签列。
- 如果结果集中的某列全部为 NULL 值，则该列的返回结果也是 NULL。
- 如果要返回各个列的首个（时间戳最小）非 NULL 值，可以使用 FIRST(\*) 查询超级表，且 multiResultFunctionStarReturnTags 设置为 0 (默认值) 时，FIRST(\*) 只返回超级表的普通列；设置为 1 时，返回超级表的普通列和标签列。
- 如果结果集中的某列全部为 NULL 值，则该列的返回结果也是 NULL；
- 如果结果集中所有列全部为 NULL 值，则不返回结果。
- 对于存在复合主键的表的查询，若最小时间戳的数据有多条，则只有对应的复合主键最小的数据被返回。
@ -1877,7 +1878,7 @@ ignore_null_values: {
- INTERP 用于在指定时间断面获取指定列的记录值，如果该时间断面不存在符合条件的行数据，那么会根据 FILL 参数的设定进行插值。
- INTERP 的输入数据为指定列的数据，可以通过条件语句（where 子句）来对原始列数据进行过滤，如果没有指定过滤条件则输入为全部数据。
- INTERP SQL 查询需要同时与 RANGE，EVERY 和 FILL 关键字一起使用；流计算不能使用 RANGE，需要 EVERY 和 FILL 关键字一起使用。
- INTERP SQL 查询需要同时与 RANGE、EVERY 和 FILL 关键字一起使用；流计算不能使用 RANGE，需要 EVERY 和 FILL 关键字一起使用。
- INTERP 的输出时间范围根据 RANGE(timestamp1, timestamp2) 字段来指定，需满足 timestamp1 \<= timestamp2。其中 timestamp1 为输出时间范围的起始值，即如果 timestamp1 时刻符合插值条件则 timestamp1 为输出的第一条记录，timestamp2 为输出时间范围的结束值，即输出的最后一条记录的 timestamp 不能大于 timestamp2。
- INTERP 根据 EVERY(time_unit) 字段来确定输出时间范围内的结果条数，即从 timestamp1 开始每隔固定长度的时间（time_unit 值）进行插值，time_unit 可取值时间单位：1a(毫秒)，1s(秒)，1m(分)，1h(小时)，1d(天)，1w(周)。例如 EVERY(500a) 将对于指定数据每500毫秒间隔进行一次插值。
- INTERP 根据 FILL 字段来决定在每个符合输出条件的时刻如何进行插值。关于 FILL 子句如何使用请参考 [FILL 子句](../distinguished/#fill-子句)
@ -1947,7 +1948,7 @@ MAX(expr)
**适用于**：表和超级表。
**使用说明**：
- max 函数可以接受字符串作为输入参数，当输入参数为字符串类型时，返回最大的字符串值，从 3.3.3.0 版本开始支持，之前的版本不支持字符串参数。
- max 函数可以接受字符串作为输入参数，当输入参数为字符串类型时，返回最大的字符串值，从 v3.3.3.0 开始支持，之前的版本不支持字符串参数。
### MIN
@ -1964,7 +1965,7 @@ MIN(expr)
**适用于**：表和超级表。
**使用说明**：
- min 函数可以接受字符串作为输入参数，当输入参数为字符串类型时，返回最大的字符串值，从 3.3.3.0 版本开始支持，之前的版本不支持字符串参数。
- min 函数可以接受字符串作为输入参数，当输入参数为字符串类型时，返回最大的字符串值，从 v3.3.3.0 开始支持，之前的版本不支持字符串参数。
### MODE
@ -2031,8 +2032,8 @@ TOP(expr, k)
**使用说明**：
- *k* 取值范围 1≤*k*≤100。
- 系统同时返回该记录关联的时间戳列。
- *k* 值取值范围 1≤*k*≤100；
- 系统同时返回该记录关联的时间戳列；
- 限制：TOP 函数不支持 FILL 子句。
### UNIQUE
@ -2063,12 +2064,12 @@ COLS(func(expr), output_expr1, [, output_expr2] ... )
**适用于**：表和超级表。
**使用说明:**
**使用说明**：
- func 函数类型：必须是单行选择函数（输出结果为一行的选择函数，例如 last 是单行选择函数，但 top 是多行选择函数）。
- 主要用于一个 sql 中获取多个选择函数结果关联列的场景，例如: select cols(max(c0), ts), cols(max(c1), ts) from ...可用于获取 c0, c1 列最大值的不同 ts 值。
- 注意, 函数 func 的结果并没有返回，如需输出 func 结果，可额外增加输出列，如: select fist(ts), cols(first(ts), c1) from ...
- 输出只有一列时，可以对 cols 函数设置别名。例如: "select cols(first(ts), c1) as c11 from ..."
- 输出一列或者多列时，可以对 cols 函数的每个输出列设置命名。例如: "select cols(first(ts), c1 as c11, c2 as c22)"
- 主要用于一个 sql 中获取多个选择函数结果关联列的场景，例如 `select cols(max(c0), ts), cols(max(c1), ts) from ...` 可用于获取 c0、c1 列最大值的不同 ts 值。
- 注意，函数 func 的结果并没有返回，如需输出 func 结果，可额外增加输出列，如 `select fist(ts), cols(first(ts), c1) from ...`
- 输出只有一列时，可以对 cols 函数设置别名。例如 `select cols(first(ts), c1) as c11 from ...`
- 输出一列或者多列时，可以对 cols 函数的每个输出列设置命名。例如 `select cols(first(ts), c1 as c11, c2 as c22)`
## 时序数据特有函数
@ -2083,7 +2084,7 @@ CSUM(expr)
**功能说明**：累加和（Cumulative sum），忽略 NULL 值。
**返回结果类型**：输入列如果是整数类型返回值为长整型 （int64_t），浮点数返回值为双精度浮点数（Double）。无符号整数类型返回值为无符号长整型（uint64_t）。
**返回结果类型**：输入列如果是整数类型返回值为长整型（bigint），浮点数返回值为双精度浮点数（double）。无符号整数类型返回值为无符号长整型（unsigned bigint）。
**适用数据类型**：数值类型。
@ -2118,7 +2119,7 @@ ignore_negative: {
**使用说明**：
- 可以与选择相关联的列一起使用，例如 select \_rowts, DERIVATIVE(col1, 1s, 1) from tb1。
- 可以与选择相关联的列一起使用。例如 `select \_rowts, DERIVATIVE(col1, 1s, 1) from tb1`。
### DIFF
@ -2133,14 +2134,14 @@ ignore_option: {
}
```
**功能说明**：统计表中特定列与之前行的当前列有效值之差。ignore_option 取值为 0|1|2|3，可以不填，默认值为 0。
**功能说明**：统计表中特定列与之前行的当前列有效值之差。ignore_option 取值为 0|1|2|3，可以不填，默认值为 0.
- `0` 表示不忽略(diff结果)负值不忽略 null 值
- `1` 表示(diff结果)负值作为 null 值
- `2` 表示不忽略(diff结果)负值但忽略 null 值
- `3` 表示忽略(diff结果)负值且忽略 null 值
- 对于存在复合主键的表的查询，若时间戳相同的数据存在多条，则只有对应的复合主键最小的数据参与运算。
**返回数据类型**：bool、时间戳及整型数值类型均返回 int64，浮点类型返回 double，若 diff 结果溢出则返回溢出后的值。
**返回数据类型**：bool、时间戳及整型数值类型均返回 bigint，浮点类型返回 double，若 diff 结果溢出则返回溢出后的值。
**适用数据类型**：数值类型、时间戳和 bool 类型。
@ -2149,13 +2150,13 @@ ignore_option: {
**使用说明**：
- diff 是计算本行特定列与同列的前一个有效数据的差值，同列的前一个有效数据：指的是同一列中时间戳较小的最临近的非空值。
- 数值类型 diff 结果为对应的算术差值；时间戳类型根据数据库的时间戳精度进行差值计算；bool 类型计算差值时 true 视为 1，false 视为 0。
- 如当前行数据为 null 或者没有找到同列前一个有效数据时，diff 结果为 null。
- 忽略负值时（ignore_option 设置为 1 或 3 ），如果 diff 结果为负值，则结果设置为 null，然后根据 null 值过滤规则进行过滤。
- 当 diff 结果发生溢出时，结果是否是 `应该忽略的负值` 取决于逻辑运算结果是正数还是负数，例如 9223372036854775800 - (-9223372036854775806) 的值超出 BIGINT 的范围 ，diff 结果会显示溢出值 -10，但并不会被作为负值忽略。
- 单个语句中可以使用单个或者多个 diff，并且每个 diff 可以指定相同或不同的 ignore_option ，当单个语句中存在多个 diff 时当且仅当某行所有 diff 的结果都为 null ，并且 ignore_option 都设置为忽略 null 值，该行才从结果集中剔除。
- 可以选择与相关联的列一起使用。例如 select _rowts, DIFF() from。
- 当没有复合主键时，如果不同的子表有相同时间戳的数据，会提示 "Duplicate timestamps not allowed"。
- 数值类型 diff 结果为对应的算术差值；时间戳类型根据数据库的时间戳精度进行差值计算；bool 类型计算差值时 true 视为 1，false 视为 0
- 如当前行数据为 null 或者没有找到同列前一个有效数据时，diff 结果为 null
- 忽略负值时（ignore_option 设置为 1 或 3 ），如果 diff 结果为负值，则结果设置为 null，然后根据 null 值过滤规则进行过滤
- 当 diff 结果发生溢出时，结果是否是 `应该忽略的负值` 取决于逻辑运算结果是正数还是负数，例如 9223372036854775800 - (-9223372036854775806) 的值超出 BIGINT 的范围，diff 结果会显示溢出值 -10，但并不会被作为负值忽略
- 单个语句中可以使用单个或者多个 diff，并且每个 diff 可以指定相同或不同的 ignore_option，当单个语句中存在多个 diff 时当且仅当某行所有 diff 的结果都为 null，并且 ignore_option 都设置为忽略 null 值，该行才从结果集中剔除
- 可以选择与相关联的列一起使用。例如 `select _rowts, DIFF() from`。
- 当没有复合主键时，如果不同的子表有相同时间戳的数据，会提示 "Duplicate timestamps not allowed"
- 当使用复合主键时，不同子表的时间戳和主键组合可能相同，使用哪一行取决于先找到哪一行，这意味着在这种情况下多次运行 diff() 的结果可能会不同。
### IRATE
@ -2218,7 +2219,7 @@ STATECOUNT(expr, oper, val)
**使用说明**：
- 不能和窗口操作一起使用，例如 interval/state_window/session_window。
- 不能和窗口操作一起使用，例如 `interval/state_window/session_window`。
### STATEDURATION
@ -2296,7 +2297,7 @@ SELECT SERVER_VERSION();
SELECT SERVER_STATUS();
```
**说明**：检测服务端是否所有 dnode 都在线，如果是则返回成功，否则返回无法建立连接的错误。如果想要查询集群的状态，推荐使用 `SHOW CLUSTER ALIVE;`，与 `SELECT SERVER_STATUS();` 不同，当集群中的部分节点不可用时，它不会返回错误，而是返回不同的状态码，详见：[SHOW CLUSTER ALIVE](https://docs.taosdata.com/reference/taos-sql/show/#show-cluster-alive)
**说明**：检测服务端是否所有 dnode 都在线，如果是则返回成功，否则返回无法建立连接的错误。如果想要查询集群的状态，推荐使用 `SHOW CLUSTER ALIVE` 与 `SELECT SERVER_STATUS()` 不同，当集群中的部分节点不可用时，它不会返回错误，而是返回不同的状态码，详见：[SHOW CLUSTER ALIVE](https://docs.taosdata.com/reference/taos-sql/show/#show-cluster-alive)
### CURRENT_USER
@ -2309,7 +2310,7 @@ SELECT CURRENT_USER();
## Geometry 函数
### Geometry 输入函数：
### Geometry 输入函数
#### ST_GeomFromText
@ -2323,7 +2324,7 @@ ST_GeomFromText(VARCHAR WKT expr)
**适用数据类型**：VARCHAR。
**适用表类型**：表和超级表。
**适用表类型**：标准表和超表。
**使用说明**：输入可以是 WKT 字符串之一，例如点（POINT）、线串（LINESTRING）、多边形（POLYGON）、多点集（MULTIPOINT）、多线串（MULTILINESTRING）、多多边形（MULTIPOLYGON）、几何集合（GEOMETRYCOLLECTION）。输出是以二进制字符串形式定义的 GEOMETRY 数据类型。
@ -2341,7 +2342,7 @@ ST_AsText(GEOMETRY geom)
**适用数据类型**：GEOMETRY。
**适用表类型**：表和超级表。
**适用表类型**：标准表和超表。
**使用说明**：输出可以是 WKT 字符串之一，例如点（POINT）、线串（LINESTRING）、多边形（POLYGON）、多点集（MULTIPOINT）、多线串（MULTILINESTRING）、多多边形（MULTIPOLYGON）、几何集合（GEOMETRYCOLLECTION）。
@ -2359,7 +2360,7 @@ ST_Intersects(GEOMETRY geomA, GEOMETRY geomB)
**适用数据类型**：GEOMETRY、GEOMETRY。
**适用表类型**：表和超级表。
**适用表类型**：标准表和超表。
**使用说明**：如果两个几何对象有任何一个共享点，则它们相交。
@ -2375,7 +2376,7 @@ ST_Equals(GEOMETRY geomA, GEOMETRY geomB)
**适用数据类型**：GEOMETRY、GEOMETRY。
**适用表类型**：表和超级表。
**适用表类型**：标准表和超表。
**使用说明**："空间相等"意味着 ST_Contains(A,B) = true 和 ST_Contains(B,A) = true，并且点的顺序可能不同，但表示相同的几何结构。
@ -2391,7 +2392,7 @@ ST_Touches(GEOMETRY geomA, GEOMETRY geomB)
**适用数据类型**：GEOMETRY、GEOMETRY。
**适用表类型**：表和超级表。
**适用表类型**：标准表和超表。
**使用说明**：A 和 B 至少有一个公共点，并且这些公共点位于至少一个边界中。对于点/点输入，关系始终为 FALSE，因为点没有边界。
@ -2407,7 +2408,7 @@ ST_Covers(GEOMETRY geomA, GEOMETRY geomB)
**适用数据类型**：GEOMETRY、GEOMETRY。
**适用表类型**：表和超级表。
**适用表类型**：标准表和超表。
**使用说明**：A 包含 B 意味着 B 中的没有点位于 A 的外部（在外部）。
@ -2421,9 +2422,9 @@ ST_Contains(GEOMETRY geomA, GEOMETRY geomB)
**返回值类型**：BOOL。
**适用数据类型**：GEOMETRY，GEOMETRY。
**适用数据类型**：GEOMETRY、GEOMETRY。
**适用表类型**：表和超级表。
**适用表类型**：标准表和超表。
**使用说明**：A 包含 B 当且仅当 B 的所有点位于 A 的内部（即位于内部或边界上）（或等效地，B 的没有点位于 A 的外部），并且 A 和 B 的内部至少有一个公共点。
@ -2439,6 +2440,6 @@ ST_ContainsProperly(GEOMETRY geomA, GEOMETRY geomB)
**适用数据类型**：GEOMETRY、GEOMETRY。
**适用表类型**：表和超级表。
**适用表类型**：标准表和超表。
**使用说明**：B 的没有点位于 A 的边界或外部。

36
docs/zh/14-reference/03-taos-sql/12-distinguished.md
View File

@ -54,9 +54,9 @@ window_clause: {
```
其中，interval_val 和 sliding_val 都表示时间段，interval_offset 表示窗口偏移量，interval_offset 必须小于 interval_val，语法上支持三种方式，举例说明如下:
- INTERVAL(1s, 500a) SLIDING(1s), 自带时间单位的形式，其中的时间单位是单字符表示, 分别为: a (毫秒), b (纳秒), d (天), h (小时), m (分钟), n (月), s (秒), u (微秒), w (周), y (年).
- INTERVAL(1000, 500) SLIDING(1000), 不带时间单位的形式，将使用查询库的时间精度作为默认时间单位，当存在多个库时默认采用精度更高的库.
- INTERVAL('1s', '500a') SLIDING('1s'), 自带时间单位的字符串形式，字符串内部不能有任何空格等其它字符.
- `INTERVAL(1s, 500a) SLIDING(1s)` 自带时间单位的形式，其中的时间单位是单字符表示，分别为: a (毫秒)、b (纳秒)、d (天)、h (小时)、m (分钟)、n (月)、s (秒)、u (微秒)、w (周)、y (年)。
- `INTERVAL(1000, 500) SLIDING(1000)` 不带时间单位的形式，将使用查询库的时间精度作为默认时间单位，当存在多个库时默认采用精度更高的库。
- `INTERVAL('1s', '500a') SLIDING('1s')` 自带时间单位的字符串形式，字符串内部不能有任何空格等其它字符。
### 窗口子句的规则
@ -76,19 +76,19 @@ window_clause: {
FILL 语句指定某一窗口区间数据缺失的情况下的填充模式。填充模式包括以下几种：
1. 不进行填充：NONE（默认填充模式）。
2. VALUE 填充：固定值填充，此时需要指定填充的数值。例如：FILL(VALUE, 1.23)。这里需要注意，最终填充的值受由相应列的类型决定，如 FILL(VALUE, 1.23)，相应列为 INT 类型，则填充值为 1, 若查询列表中有多列需要 FILL, 则需要给每一个 FILL 列指定 VALUE, 如 `SELECT _wstart, min(c1), max(c1) FROM ... FILL(VALUE, 0, 0)`, 注意, SELECT 表达式中只有包含普通列时才需要指定 FILL VALUE, 如 `_wstart`, `_wstart+1a`, `now`, `1+1` 以及使用 partition by 时的 partition key (如 tbname)都不需要指定 VALUE, 如 `timediff(last(ts), _wstart)` 则需要指定VALUE。
3. PREV 填充：使用前一个非 NULL 值填充数据。例如：FILL(PREV)。
4. NULL 填充：使用 NULL 填充数据。例如：FILL(NULL)。
5. LINEAR 填充：根据前后距离最近的非 NULL 值做线性插值填充。例如：FILL(LINEAR)。
6. NEXT 填充：使用下一个非 NULL 值填充数据。例如：FILL(NEXT)。
2. VALUE 填充：固定值填充，此时需要指定填充的数值。例如 FILL(VALUE, 1.23)。这里需要注意，最终填充的值受由相应列的类型决定，如 FILL(VALUE, 1.23)，相应列为 INT 类型，则填充值为 1，若查询列表中有多列需要 FILL，则需要给每一个 FILL 列指定 VALUE，如 `SELECT _wstart, min(c1), max(c1) FROM ... FILL(VALUE, 0, 0)`，注意，SELECT 表达式中只有包含普通列时才需要指定 FILL VALUE，如 `_wstart`、`_wstart+1a`、`now`、`1+1` 以及使用 partition by 时的 partition key (如 tbname)都不需要指定 VALUE，如 `timediff(last(ts), _wstart)` 则需要指定 VALUE。
3. PREV 填充：使用前一个非 NULL 值填充数据。例如 FILL(PREV)。
4. NULL 填充：使用 NULL 填充数据。例如 FILL(NULL)。
5. LINEAR 填充：根据前后距离最近的非 NULL 值做线性插值填充。例如 FILL(LINEAR)。
6. NEXT 填充：使用下一个非 NULL 值填充数据。例如 FILL(NEXT)。
以上填充模式中，除了 NONE 模式默认不填充值之外，其他模式在查询的整个时间范围内如果没有数据 FILL 子句将被忽略，即不产生填充数据，查询结果为空。这种行为在部分模式（PREV、NEXT、LINEAR）下具有合理性，因为在这些模式下没有数据意味着无法产生填充数值。而对另外一些模式（NULL、VALUE）来说，理论上是可以产生填充数值的，至于需不需要输出填充数值，取决于应用的需求。所以为了满足这类需要强制填充数据或 NULL 的应用的需求，同时不破坏现有填充模式的行为兼容性，从 3.0.3.0 版本开始，增加了两种新的填充模式：
以上填充模式中，除了 NONE 模式默认不填充值之外，其他模式在查询的整个时间范围内如果没有数据 FILL 子句将被忽略，即不产生填充数据，查询结果为空。这种行为在部分模式（PREV、NEXT、LINEAR）下具有合理性，因为在这些模式下没有数据意味着无法产生填充数值。而对另外一些模式（NULL、VALUE）来说，理论上是可以产生填充数值的，至于需不需要输出填充数值，取决于应用的需求。所以为了满足这类需要强制填充数据或 NULL 的应用的需求，同时不破坏现有填充模式的行为兼容性，从 v3.0.3.0 开始，增加了两种新的填充模式：
7. NULL_F: 强制填充 NULL 值
8. VALUE_F: 强制填充 VALUE 值
7. NULL_F：强制填充 NULL 值
8. VALUE_F：强制填充 VALUE 值
NULL, NULL_F, VALUE, VALUE_F 这几种填充模式针对不同场景区别如下：
- INTERVAL 子句： NULL_F, VALUE_F 为强制填充模式；NULL, VALUE 为非强制模式。在这种模式下下各自的语义与名称相符
NULL、NULL_F、VALUE、 VALUE_F 这几种填充模式针对不同场景区别如下：
- INTERVAL 子句：NULL_F、VALUE_F 为强制填充模式；NULL、VALUE 为非强制模式。在这种模式下下各自的语义与名称相符
- 流计算中的 INTERVAL 子句：NULL_F 与 NULL 行为相同，均为非强制模式；VALUE_F 与 VALUE 行为相同，均为非强制模式。即流计算中的 INTERVAL 没有强制模式
- INTERP 子句：NULL 与 NULL_F 行为相同，均为强制模式；VALUE 与 VALUE_F 行为相同，均为强制模式。即 INTERP 中没有非强制模式。
@ -139,7 +139,7 @@ SELECT COUNT(*) FROM meters WHERE _rowts - voltage > 1000000;
- 使用 INTERVAL 语句时，除非极特殊的情况，都要求把客户端和服务端的 taos.cfg 配置文件中的 timezone 参数配置为相同的取值，以避免时间处理函数频繁进行跨时区转换而导致的严重性能影响。
- 返回的结果中时间序列严格单调递增。
- 使用 AUTO 作为窗口偏移量时，如果 WHERE 时间条件比较复杂，比如多个 AND/OR/IN 互相组合，那么 AUTO 可能不生效，这种情况可以通过手动指定窗口偏移量进行解决。
- 使用 AUTO 作为窗口偏移量时，如果窗口宽度的单位是 d (天), n (月), w (周), y (年)，比如: INTERVAL(1d, AUTO), INTERVAL(3w, AUTO)，此时 TSMA 优化无法生效。如果目标表上手动创建了TSMA，语句会报错退出；这种情况下，可以显式指定 Hint SKIP_TSMA 或者不使用 AUTO 作为窗口偏移量。
- 使用 AUTO 作为窗口偏移量时，如果窗口宽度的单位是 d (天)、n (月)、w (周)、y (年)，比如 `INTERVAL(1d, AUTO)`、`INTERVAL(3w, AUTO)`，此时 TSMA 优化无法生效。如果目标表上手动创建了 TSMA，语句会报错退出；这种情况下，可以显式指定 Hint SKIP_TSMA 或者不使用 AUTO 作为窗口偏移量。
### 状态窗口
@ -147,13 +147,13 @@ SELECT COUNT(*) FROM meters WHERE _rowts - voltage > 1000000;
![TDengine Database 时间窗口示意图](./timewindow-3.webp)
使用 STATE_WINDOW 来确定状态窗口划分的列。例如：
使用 STATE_WINDOW 来确定状态窗口划分的列。例如
```
SELECT COUNT(*), FIRST(ts), status FROM temp_tb_1 STATE_WINDOW(status);
```
仅关心 status 为 2 时的状态窗口的信息。例如：
仅关心 status 为 2 时的状态窗口的信息。例如
```
SELECT * FROM (SELECT COUNT(*) AS cnt, FIRST(ts) AS fst, status FROM temp_tb_1 STATE_WINDOW(status)) t WHERE status = 2;
@ -173,7 +173,7 @@ SELECT COUNT(*), FIRST(ts), status FROM temp_tb_1 STATE_WINDOW(status) TRUE_FOR
### 会话窗口
会话窗口根据记录的时间戳主键的值来确定是否属于同一个会话。如下图所示，如果设置时间戳的连续的间隔小于等于 12 秒，则以下 6 条记录构成 2 个会话窗口，分别是：[2019-04-28 14:22:10，2019-04-28 14:22:30]和[2019-04-28 14:23:10，2019-04-28 14:23:30]。因为 2019-04-28 14:22:30 与 2019-04-28 14:23:10 之间的时间间隔是 40 秒，超过了连续时间间隔（12 秒）。
会话窗口根据记录的时间戳主键的值来确定是否属于同一个会话。如下图所示，如果设置时间戳的连续的间隔小于等于 12 秒，则以下 6 条记录构成 2 个会话窗口，分别是 [2019-04-28 14:22:10，2019-04-28 14:22:30] 和 [2019-04-28 14:23:10，2019-04-28 14:23:30]。因为 2019-04-28 14:22:30 与 2019-04-28 14:23:10 之间的时间间隔是 40 秒，超过了连续时间间隔（12 秒）。
![TDengine Database 时间窗口示意图](./timewindow-2.webp)
@ -223,7 +223,7 @@ select _wstart, _wend, count(*) from t count_window(4);
### 时间戳伪列
窗口聚合查询结果中，如果 SQL 语句中没有指定输出查询结果中的时间戳列，那么最终结果中不会自动包含窗口的时间列信息。如果需要在结果中输出聚合结果所对应的时间窗口信息，需要在 SELECT 子句中使用时间戳相关的伪列: 时间窗口起始时间 (\_WSTART), 时间窗口结束时间 (\_WEND), 时间窗口持续时间 (\_WDURATION), 以及查询整体窗口相关的伪列: 查询窗口起始时间(\_QSTART) 和查询窗口结束时间(\_QEND)。需要注意的是时间窗口起始时间和结束时间均是闭区间，时间窗口持续时间是数据当前时间分辨率下的数值。例如，如果当前数据库的时间分辨率是毫秒，那么结果中 500 就表示当前时间窗口的持续时间是 500毫秒 (500 ms)。
窗口聚合查询结果中，如果 SQL 语句中没有指定输出查询结果中的时间戳列，那么最终结果中不会自动包含窗口的时间列信息。如果需要在结果中输出聚合结果所对应的时间窗口信息，需要在 SELECT 子句中使用时间戳相关的伪列: 时间窗口起始时间 (\_WSTART), 时间窗口结束时间 (\_WEND), 时间窗口持续时间 (\_WDURATION), 以及查询整体窗口相关的伪列：查询窗口起始时间(\_QSTART) 和查询窗口结束时间(\_QEND)。需要注意的是时间窗口起始时间和结束时间均是闭区间，时间窗口持续时间是数据当前时间分辨率下的数值。例如，如果当前数据库的时间分辨率是毫秒，那么结果中 500 就表示当前时间窗口的持续时间是 500毫秒 (500 ms)。
### 示例

13
docs/zh/14-reference/03-taos-sql/13-tmq.md
View File

@ -10,7 +10,7 @@ TDengine 3.0.0.0 开始对消息队列做了大幅的优化和增强以简化用
TDengine 创建 topic 的个数上限通过参数 tmqMaxTopicNum 控制，默认 20 个。
TDengine 使用 SQL 创建一个 topic，共有三种类型的 topic：
TDengine 使用 SQL 创建一个 topic，共有三种类型的 topic。
### 查询 topic
@ -20,12 +20,13 @@ TDengine 使用 SQL 创建一个 topic，共有三种类型的 topic：
CREATE TOPIC [IF NOT EXISTS] topic_name as subquery
```
通过 `SELECT` 语句订阅（包括 `SELECT *`，或 `SELECT ts, c1` 等指定查询订阅，可以带条件过滤、标量函数计算，但不支持聚合函数、不支持时间窗口聚合）。需要注意的是：
通过 `SELECT` 语句订阅（包括 `SELECT *` 或 `SELECT ts, c1` 等指定查询订阅，可以带条件过滤、标量函数计算，但不支持聚合函数、不支持时间窗口聚合）。需要注意的是：
- 该类型 TOPIC 一旦创建则订阅数据的结构确定。
- 被订阅或用于计算的列或标签不可被删除（`ALTER table DROP`）、修改（`ALTER table MODIFY`）。
- 若发生表结构变更，新增的列不出现在结果中。
- 对于 select \*，则订阅展开为创建时所有的列（子表、普通表为数据列，超级表为数据列加标签列）
- 对于 select \*，则订阅展开为创建时所有的列（子表、普通表为数据列，超级表为数据列加标签列）。
### 超级表 topic
语法：
@ -38,7 +39,7 @@ CREATE TOPIC [IF NOT EXISTS] topic_name [with meta] AS STABLE stb_name [where_co
- 不会限制用户的表结构变更。
- 返回的是非结构化的数据：返回数据的结构会随之超级表的表结构变化而变化。
- with meta 参数可选，选择时将返回创建超级表，子表等语句，主要用于taosx做超级表迁移
- with meta 参数可选，选择时将返回创建超级表，子表等语句，主要用于 taosX 做超级表迁移。
- where_condition 参数可选，选择时将用来过滤符合条件的子表，订阅这些子表。where 条件里不能有普通列，只能是 tag 或 tbname，where 条件里可以用函数，用来过滤 tag，但是不能是聚合函数，因为子表 tag 值无法做聚合。也可以是常量表达式，比如 2 > 1（订阅全部子表），或者 false（订阅 0 个子表）
- 返回数据不包含标签。
@ -52,9 +53,9 @@ CREATE TOPIC [IF NOT EXISTS] topic_name [with meta] AS DATABASE db_name;
通过该语句可创建一个包含数据库所有表数据的订阅
- with meta 参数可选，选择时将返回创建数据库里所有超级表，子表的语句，主要用于taosx做数据库迁移
- with meta 参数可选，选择时将返回创建数据库里所有超级表，子表的语句，主要用于 taosX 做数据库迁移。
说明： 超级表订阅和库订阅属于高级订阅模式，容易出错，如确实要使用，请咨询专业人员。
说明：超级表订阅和库订阅属于高级订阅模式，容易出错，如确实要使用，请咨询 TDengine 运维团队。
## 删除 topic

8
docs/zh/14-reference/03-taos-sql/14-stream.md
View File

@ -20,7 +20,7 @@ stream_options: {
```
其中 subquery 是 select 普通查询语法的子集:
其中 subquery 是 select 普通查询语法的子集。
```sql
subquery: SELECT select_list
@ -101,7 +101,7 @@ notification_definition 子句定义了窗口计算过程中，在窗口打开/
CREATE STREAM avg_vol_s INTO avg_vol SUBTABLE(CONCAT('new-', tname)) AS SELECT _wstart, count(*), avg(voltage) FROM meters PARTITION BY tbname tname INTERVAL(1m);
```
PARTITION 子句中，为 tbname 定义了一个别名 tname, 在 PARTITION 子句中的别名可以用于 SUBTABLE 子句中的表达式计算，在上述示例中，流新创建的子表将以前缀 'new-' 连接原表名作为表名（从 3.2.3.0 版本开始，为了避免 SUBTABLE 中的表达式无法区分各个子表，即误将多个相同时间线写入一个子表，在指定的子表名后面加上 _stableName_groupId）。
PARTITION 子句中，为 tbname 定义了一个别名 tname, 在 PARTITION 子句中的别名可以用于 SUBTABLE 子句中的表达式计算，在上述示例中，流新创建的子表将以前缀 'new-' 连接原表名作为表名（从 v3.2.3.0 开始，为了避免 SUBTABLE 中的表达式无法区分各个子表，即误将多个相同时间线写入一个子表，在指定的子表名后面加上 _stableName_groupId）。
注意，子表名的长度若超过 TDengine 的限制，将被截断。若要生成的子表名已经存在于另一超级表，由于 TDengine 的子表名是唯一的，因此对应新子表的创建以及数据的写入将会失败。
@ -151,7 +151,7 @@ SELECT * from information_schema.`ins_streams`;
在创建流时，可以通过 TRIGGER 指令指定流式计算的触发模式。
对于非窗口计算，流式计算的触发是实时的；对于窗口计算，目前提供 4 种触发模式，默认为 WINDOW_CLOSE：
对于非窗口计算，流式计算的触发是实时的；对于窗口计算，目前提供 4 种触发模式，默认为 WINDOW_CLOSE。
1. AT_ONCE：写入立即触发
@ -283,7 +283,7 @@ RESUME STREAM [IF EXISTS] [IGNORE UNTREATED] stream_name;
没有指定 IF EXISTS，如果该 stream 不存在，则报错，如果存在，则恢复流计算；指定了 IF EXISTS，如果 stream 不存在，则返回成功；如果存在，则恢复流计算。如果指定 IGNORE UNTREATED，则恢复流计算时，忽略流计算暂停期间写入的数据。
## 状态数据备份与同步
流计算的中间结果成为计算的状态数据，需要在流计算整个生命周期中进行持久化保存。为了确保流计算中间状态能够在集群环境下在不同的节点间可靠地同步和迁移，从 3.3.2.1 版本开始，需要在运行环境中部署 rsync 软件，还需要增加以下的步骤：
流计算的中间结果成为计算的状态数据，需要在流计算整个生命周期中进行持久化保存。为了确保流计算中间状态能够在集群环境下在不同的节点间可靠地同步和迁移，从 v3.3.2.1 开始，需要在运行环境中部署 rsync 软件，还需要增加以下的步骤：
1. 在配置文件中配置 snode 的地址（IP + 端口）和状态数据备份目录（该目录系 snode 所在的物理节点的目录）。
2. 然后创建 snode。
完成上述两个步骤以后才能创建流。

4
docs/zh/14-reference/03-taos-sql/index.md
View File

@ -16,7 +16,7 @@ TDengine SQL 是用户对 TDengine 进行数据写入和查询的主要工具。
- | 表示多选一，选择其中一个即可，但不能输入 | 本身
- … 表示前面的项可重复多个
为更好地说明 SQL 语法的规则及其特点，本文假设存在一个数据集。以智能电表(meters)为例，假设每个智能电表采集电流、电压、相位三个量。其建模如下：
为更好地说明 SQL 语法的规则及其特点，本文假设存在一个数据集。以智能电表（meters）为例，假设每个智能电表采集电流、电压、相位三个量。其建模如下：
```
taos> DESCRIBE meters;
@ -30,7 +30,7 @@ taos> DESCRIBE meters;
groupid | INT | 4 | TAG |
```
数据集包含 4 个智能电表的数据，按照 TDengine 的建模规则，对应 4 个子表，其名称分别是 d1001, d1002, d1003, d1004。
数据集包含 4 个智能电表的数据，按照 TDengine 的建模规则，对应 4 个子表，其名称分别是 d1001、d1002、d1003、d1004。
```mdx-code-block
import DocCardList from '@theme/DocCardList';

40
docs/zh/14-reference/05-connector/10-cpp.mdx
View File

@ -93,16 +93,16 @@ DSN 描述字符串基本结构如下：
各部分意义见下表：
- **driver**: 必须指定驱动名以便连接器选择何种方式创建连接，支持如下驱动名：
- **taos**: 默认驱动，支持 SQL 执行，参数绑定，无模式写入。
- **tmq**: 使用 TMQ 订阅数据。
- **protocol**: 显示指定以何种方式建立连接，例如：`taos+ws://localhost:6041` 指定以 WebSocket 方式建立连接。
- **http/ws**: 使用 WebSocket 协议。
- **https/wss**: 在 WebSocket 连接方式下显示启用 SSL/TLS 协议。
- **driver**：必须指定驱动名以便连接器选择何种方式创建连接，支持如下驱动名：
- **taos**：默认驱动，支持 SQL 执行，参数绑定，无模式写入。
- **tmq**：使用 TMQ 订阅数据。
- **protocol**：显示指定以何种方式建立连接，例如：`taos+ws://localhost:6041` 指定以 WebSocket 方式建立连接。
- **http/ws**：使用 WebSocket 协议。
- **https/wss**：在 WebSocket 连接方式下显示启用 SSL/TLS 协议。
- **username/password**: 用于创建连接的用户名及密码。
- **host/port**: 指定创建连接的服务器及端口，当不指定服务器地址及端口时 WebSocket 连接默认为 `localhost:6041` 。
- **database**: 指定默认连接的数据库名，可选参数。
- **username/password**：用于创建连接的用户名及密码。
- **host/port**：指定创建连接的服务器及端口，当不指定服务器地址及端口时 WebSocket 连接默认为 `localhost:6041` 。
- **database**：指定默认连接的数据库名，可选参数。
- **params**：其他可选参数。
一个完整的 DSN 描述字符串示例如下：`taos+ws://localhost:6041/test`， 表示使用 WebSocket（`ws`）方式通过 `6041` 端口连接服务器 `localhost`，并指定默认数据库为 `test`。
@ -280,7 +280,7 @@ TDengine 推荐数据库应用的每个线程都建立一个独立的连接，
- **参数说明**：
- stmt：[入参] 指向一个有效的预编译的 SQL 语句对象指针。
- bind：[入参] 指向一个有效的 WS_MULTI_BIND 结构体指针，该结构体包含了要批量绑定到 SQL 语句中的参数列表。
- len: [入参] bind 数组的元素个数。
- len：[入参] bind 数组的元素个数。
- **返回值**：`0`：成功。非 `0`：失败，详情请参考错误码页面。
- `int ws_stmt_set_tbname(WS_STMT *stmt, const char *name)`
@ -356,8 +356,8 @@ TDengine 推荐数据库应用的每个线程都建立一个独立的连接，
协议类型是枚举类型，包含以下三种格式：
- WS_TSDB_SML_LINE_PROTOCOL：InfluxDB 行协议（Line Protocol)
- WS_TSDB_SML_TELNET_PROTOCOL: OpenTSDB Telnet 文本行协议
- WS_TSDB_SML_JSON_PROTOCOL: OpenTSDB Json 协议格式
- WS_TSDB_SML_TELNET_PROTOCOL：OpenTSDB Telnet 文本行协议
- WS_TSDB_SML_JSON_PROTOCOL：OpenTSDB Json 协议格式
时间戳分辨率的定义，定义在 `taosws.h` 文件中，具体内容如下：
@ -625,9 +625,9 @@ TDengine 服务端或客户端安装后，`taos.h` 位于：
TDengine 客户端驱动的动态库位于：
- Linux: `/usr/local/taos/driver/libtaos.so`
- Windows: `C:\TDengine\driver\taos.dll`
- macOS: `/usr/local/lib/libtaos.dylib`
- Linux：`/usr/local/taos/driver/libtaos.so`
- Windows：`C:\TDengine\driver\taos.dll`
- macOS：`/usr/local/lib/libtaos.dylib`
### 支持的平台
@ -689,7 +689,7 @@ TDengine 客户端驱动的版本号与 TDengine 服务端的版本号是一一
- `int taos_options_connection(TAOS *taos, TSDB_OPTION_CONNECTION option, const void *arg, ...)`
- **接口说明**：设置客户端连接选项，目前支持字符集设置（`TSDB_OPTION_CONNECTION_CHARSET`）、时区设置（`TSDB_OPTION_CONNECTION_TIMEZONE`）、用户 IP 设置（`TSDB_OPTION_CONNECTION_USER_IP`）、用户 APP 设置（`TSDB_OPTION_CONNECTION_USER_APP`）。
- **参数说明**：
- `taos`: [入参] taos_connect 返回的连接句柄。
- `taos`：[入参] taos_connect 返回的连接句柄。
- `option`：[入参] 设置项类型。
- `arg`：[入参] 设置项值。
- **返回值**：`0`：成功，`非0`：失败。
@ -727,7 +727,7 @@ TDengine 客户端驱动的版本号与 TDengine 服务端的版本号是一一
- **参数说明**：
- ip：[入参] TDengine 集群中任一节点的 FQDN。
- user：[入参] 用户名。
- auth: [入参] 原始密码取 32 位小写 md5。
- auth：[入参] 原始密码取 32 位小写 md5。
- db：[入参] 数据库名称，如果用户没有提供，也可以正常连接，用户可以通过该连接创建新的数据库，如果用户提供了数据库名字，则说明该数据库用户已经创建好，缺省使用该数据库。
- port：[入参] taosd 程序监听的端口。
- **返回值**：返回数据库连接，返回值为空表示失败。应用程序需要保存返回的参数，以便后续使用。
@ -866,7 +866,7 @@ TDengine 还提供性能更高的异步 API 处理数据插入、查询操作。
- **接口说明**：异步执行 SQL 语句。
- **参数说明**：
- taos：[入参] 指向数据库连接的指针，数据库连接是通过 `taos_connect()` 函数建立。
- sql: [入参] 需要执行的 SQL 语句。
- sql：[入参] 需要执行的 SQL 语句。
- fp：用户定义的回调函数，其第三个参数 `code` 用于指示操作是否成功，`0` 表示成功，负数表示失败（调用 `taos_errstr()` 可获取失败原因）。应用在定义回调函数的时候，主要处理第二个参数 `TAOS_RES *`，该参数是查询返回的结果集。
- param：应用提供的用于回调的参数。
@ -995,8 +995,8 @@ TDengine 的异步 API 均采用非阻塞调用模式。应用程序可以用多
协议类型是枚举类型，包含以下三种格式：
- TSDB_SML_LINE_PROTOCOL：InfluxDB 行协议（Line Protocol)
- TSDB_SML_TELNET_PROTOCOL: OpenTSDB Telnet 文本行协议
- TSDB_SML_JSON_PROTOCOL: OpenTSDB Json 协议格式
- TSDB_SML_TELNET_PROTOCOL：OpenTSDB Telnet 文本行协议
- TSDB_SML_JSON_PROTOCOL：OpenTSDB Json 协议格式
时间戳分辨率的定义，定义在 `taos.h` 文件中，具体内容如下：

74
docs/zh/14-reference/05-connector/14-java.mdx
View File

@ -21,8 +21,8 @@ TDengine 的 JDBC 驱动实现尽可能与关系型数据库驱动保持一致
## JDBC 和 JRE 版本兼容性
- JDBC: 支持 JDBC 4.2 及以上版本。
- JRE: 支持 JRE 8 及以上版本。
- JDBC：支持 JDBC 4.2 及以上版本。
- JRE：支持 JRE 8 及以上版本。
## 支持的平台
@ -101,7 +101,7 @@ JDBC 连接器可能报错的错误码包括 4 种：
| 0x2318 | | REST 连接中出现了数据传输异常，请检查网络情况并重试。 |
| 0x2319 | user is required | 创建连接时缺少用户名信息 |
| 0x231a | password is required | 创建连接时缺少密码信息 |
| 0x231c | httpEntity is null, sql: | REST 连接中执行出现异常 |
| 0x231c | httpEntity is null, sql | REST 连接中执行出现异常 |
| 0x231d | can't create connection with server within | 通过增加参数 httpConnectTimeout 增加连接耗时，或是请检查与 taosAdapter 之间的连接情况。 |
| 0x231e | failed to complete the task within the specified time | 通过增加参数 messageWaitTimeout 增加执行耗时，或是请检查与 taosAdapter 之间的连接情况。 |
| 0x2350 | unknown error | 未知异常，请在 github 反馈给开发人员。 |
@ -162,7 +162,7 @@ WKB规范请参考[Well-Known Binary (WKB)](https://libgeos.org/specifications/w
- connectionPools：HikariCP, Druid, dbcp, c3p0 等连接池中使用 taos-jdbcdriver。
- SpringJdbcTemplate：Spring JdbcTemplate 中使用 taos-jdbcdriver。
- mybatisplus-demo：Springboot + Mybatis 中使用 taos-jdbcdriver。
- springbootdemo: Springboot 中使用 taos-jdbcdriver。
- springbootdemo：Springboot 中使用 taos-jdbcdriver。
- consumer-demo：Consumer 消费 TDengine 数据示例，可通过参数控制消费速度。
请参考：[JDBC example](https://github.com/taosdata/TDengine/tree/main/docs/examples/JDBC)
@ -226,7 +226,7 @@ TDengine 的 JDBC URL 规范格式为：
- charset：客户端使用的字符集，默认值为系统字符集。
- locale：客户端语言环境，默认值系统当前 locale。
- timezone：客户端使用的时区，默认值为系统当前时区。
- batchfetch: true：在执行查询时批量拉取结果集；false：逐行拉取结果集。默认值为：true。开启批量拉取同时获取一批数据在查询数据量较大时批量拉取可以有效的提升查询性能。
- batchfetch：true：在执行查询时批量拉取结果集；false：逐行拉取结果集。默认值为：true。开启批量拉取同时获取一批数据在查询数据量较大时批量拉取可以有效的提升查询性能。
- batchErrorIgnore：true：在执行 Statement 的 executeBatch 时，如果中间有一条 SQL 执行失败将继续执行下面的 SQL。false：不再执行失败 SQL 后的任何语句。默认值为：false。
JDBC 原生连接的使用请参见[视频教程](https://www.taosdata.com/blog/2020/11/11/1955.html)。
@ -251,9 +251,9 @@ TDengine 中，只要保证 firstEp 和 secondEp 中一个节点有效，就可
- user：登录 TDengine 用户名，默认值 'root'。
- password：用户登录密码，默认值 'taosdata'。
- batchErrorIgnore：true：在执行 Statement 的 executeBatch 时，如果中间有一条 SQL 执行失败，继续执行下面的 SQL 了。false：不再执行失败 SQL 后的任何语句。默认值为：false。
- httpConnectTimeout: 连接超时时间，单位 ms， 默认值为 60000。
- messageWaitTimeout: 消息超时时间, 单位 ms， 默认值为 60000。
- useSSL: 连接中是否使用 SSL。
- httpConnectTimeout：连接超时时间，单位 ms， 默认值为 60000。
- messageWaitTimeout：消息超时时间, 单位 ms， 默认值为 60000。
- useSSL：连接中是否使用 SSL。
- timezone：客户端使用的时区，连接上生效，默认值为系统时区。推荐不设置，使用系统时区性能更好。
**注意**：部分配置项（比如：locale、charset）在 WebSocket 连接中不生效。
@ -269,10 +269,10 @@ TDengine 中，只要保证 firstEp 和 secondEp 中一个节点有效，就可
- user：登录 TDengine 用户名，默认值 'root'。
- password：用户登录密码，默认值 'taosdata'。
- batchErrorIgnore：true：在执行 Statement 的 executeBatch 时，如果中间有一条 SQL 执行失败，继续执行下面的 SQL 了。false：不再执行失败 SQL 后的任何语句。默认值为：false。
- httpConnectTimeout: 连接超时时间，单位 ms， 默认值为 60000。
- httpSocketTimeout: socket 超时时间，单位 ms，默认值为 60000。
- useSSL: 连接中是否使用 SSL。
- httpPoolSize: REST 并发请求大小，默认 20。
- httpConnectTimeout：连接超时时间，单位 ms， 默认值为 60000。
- httpSocketTimeout：socket 超时时间，单位 ms，默认值为 60000。
- useSSL：连接中是否使用 SSL。
- httpPoolSize：REST 并发请求大小，默认 20。
**注意**：部分配置项（比如：locale、charset 和 timezone）在 REST 连接中不生效。
@ -292,7 +292,7 @@ TDengine 中，只要保证 firstEp 和 secondEp 中一个节点有效，就可
properties 中的配置参数如下：
- TSDBDriver.PROPERTY_KEY_USER：登录 TDengine 用户名，默认值 'root'。
- TSDBDriver.PROPERTY_KEY_PASSWORD：用户登录密码，默认值 'taosdata'。
- TSDBDriver.PROPERTY_KEY_BATCH_LOAD: true：在执行查询时批量拉取结果集；false：逐行拉取结果集。默认值为：false。因历史原因使用 REST 连接时，若设置此参数为 true 会变成 WebSocket 连接。
- TSDBDriver.PROPERTY_KEY_BATCH_LOAD：true：在执行查询时批量拉取结果集；false：逐行拉取结果集。默认值为：false。因历史原因使用 REST 连接时，若设置此参数为 true 会变成 WebSocket 连接。
- TSDBDriver.PROPERTY_KEY_BATCH_ERROR_IGNORE：true：在执行 Statement 的 executeBatch 时，如果中间有一条 SQL 执行失败，继续执行下面的 sq 了。false：不再执行失败 SQL 后的任何语句。默认值为：false。
- TSDBDriver.PROPERTY_KEY_CONFIG_DIR：仅在使用 JDBC 原生连接时生效。客户端配置文件目录路径，Linux OS 上默认值 `/etc/taos`，Windows OS 上默认值 `C:/TDengine/cfg`。
- TSDBDriver.PROPERTY_KEY_CHARSET：客户端使用的字符集，默认值为系统字符集。
@ -300,21 +300,21 @@ properties 中的配置参数如下：
- TSDBDriver.PROPERTY_KEY_TIME_ZONE：
- 原生连接：客户端使用的时区，默认值为系统当前时区，全局生效。因为历史的原因，我们只支持POSIX标准的部分规范，如UTC-8(代表中国上上海), GMT-8，Asia/Shanghai 这几种形式。
- WebSocket 连接：客户端使用的时区，连接上生效，默认值为系统时区。仅支持 IANA 时区，即 Asia/Shanghai 这种形式。推荐不设置，使用系统时区性能更好。
- TSDBDriver.HTTP_CONNECT_TIMEOUT: 连接超时时间，单位 ms， 默认值为 60000。仅在 REST 连接时生效。
- TSDBDriver.HTTP_SOCKET_TIMEOUT: socket 超时时间，单位 ms，默认值为 60000。仅在 REST 连接且 batchfetch 设置为 false 时生效。
- TSDBDriver.PROPERTY_KEY_MESSAGE_WAIT_TIMEOUT: 消息超时时间, 单位 ms， 默认值为 60000。 仅 WebSocket 连接下有效。
- TSDBDriver.PROPERTY_KEY_USE_SSL: 连接中是否使用 SSL。仅在 WebSocket/REST 连接时生效。
- TSDBDriver.HTTP_POOL_SIZE: REST 并发请求大小，默认 20。
- TSDBDriver.PROPERTY_KEY_ENABLE_COMPRESSION: 传输过程是否启用压缩。仅在使用 REST/WebSocket 连接时生效。true: 启用，false: 不启用。默认为 false。
- TSDBDriver.PROPERTY_KEY_ENABLE_AUTO_RECONNECT: 是否启用自动重连。仅在使用 WebSocket 连接时生效。true: 启用，false: 不启用。默认为 false。
- TSDBDriver.HTTP_CONNECT_TIMEOUT：连接超时时间，单位 ms， 默认值为 60000。仅在 REST 连接时生效。
- TSDBDriver.HTTP_SOCKET_TIMEOUT：socket 超时时间，单位 ms，默认值为 60000。仅在 REST 连接且 batchfetch 设置为 false 时生效。
- TSDBDriver.PROPERTY_KEY_MESSAGE_WAIT_TIMEOUT：消息超时时间, 单位 ms， 默认值为 60000。 仅 WebSocket 连接下有效。
- TSDBDriver.PROPERTY_KEY_USE_SSL：连接中是否使用 SSL。仅在 WebSocket/REST 连接时生效。
- TSDBDriver.HTTP_POOL_SIZE：REST 并发请求大小，默认 20。
- TSDBDriver.PROPERTY_KEY_ENABLE_COMPRESSION：传输过程是否启用压缩。仅在使用 REST/WebSocket 连接时生效。true：启用，false：不启用。默认为 false。
- TSDBDriver.PROPERTY_KEY_ENABLE_AUTO_RECONNECT：是否启用自动重连。仅在使用 WebSocket 连接时生效。true：启用，false：不启用。默认为 false。
> **注意**：启用自动重连仅对简单执行 SQL 语句以及 无模式写入、数据订阅有效。对于参数绑定无效。自动重连仅对连接建立时通过参数指定数据库有效，对后面的 `use db` 语句切换数据库无效。
- TSDBDriver.PROPERTY_KEY_RECONNECT_INTERVAL_MS: 自动重连重试间隔，单位毫秒，默认值 2000。仅在 PROPERTY_KEY_ENABLE_AUTO_RECONNECT 为 true 时生效。
- TSDBDriver.PROPERTY_KEY_RECONNECT_RETRY_COUNT: 自动重连重试次数，默认值 3，仅在 PROPERTY_KEY_ENABLE_AUTO_RECONNECT 为 true 时生效。
- TSDBDriver.PROPERTY_KEY_DISABLE_SSL_CERT_VALIDATION: 关闭 SSL 证书验证 。仅在使用 WebSocket 连接时生效。true: 启用，false: 不启用。默认为 false。
- TSDBDriver.PROPERTY_KEY_RECONNECT_INTERVAL_MS：自动重连重试间隔，单位毫秒，默认值 2000。仅在 PROPERTY_KEY_ENABLE_AUTO_RECONNECT 为 true 时生效。
- TSDBDriver.PROPERTY_KEY_RECONNECT_RETRY_COUNT：自动重连重试次数，默认值 3，仅在 PROPERTY_KEY_ENABLE_AUTO_RECONNECT 为 true 时生效。
- TSDBDriver.PROPERTY_KEY_DISABLE_SSL_CERT_VALIDATION：关闭 SSL 证书验证 。仅在使用 WebSocket 连接时生效。true：启用，false：不启用。默认为 false。
- TSDBDriver.PROPERTY_KEY_APP_NAME: App 名称，可用于 `show connections` 查询结果显示。仅在使用 WebSocket 连接时生效。默认值为 java。
- TSDBDriver.PROPERTY_KEY_APP_IP: App IP，可用于 `show connections` 查询结果显示。仅在使用 WebSocket 连接时生效。默认值为空。
- TSDBDriver.PROPERTY_KEY_APP_NAME：App 名称，可用于 `show connections` 查询结果显示。仅在使用 WebSocket 连接时生效。默认值为 java。
- TSDBDriver.PROPERTY_KEY_APP_IP：App IP，可用于 `show connections` 查询结果显示。仅在使用 WebSocket 连接时生效。默认值为空。
此外对 JDBC 原生连接，通过指定 URL 和 Properties 还可以指定其他参数，比如日志级别、SQL 长度等。
@ -1364,18 +1364,18 @@ JDBC 标准不支持数据订阅，因此本章所有接口都是扩展接口。
- **异常**：如果创建失败，抛出 SQLException 异常。
创建消费者支持属性列表：
- td.connect.type: 连接方式。jni：表示使用动态库连接的方式，ws/WebSocket：表示使用 WebSocket 进行数据通信。默认为 jni 方式。
- bootstrap.servers: TDengine 服务端所在的`ip:port`，如果使用 WebSocket 连接，则为 taosAdapter 所在的`ip:port`。
- enable.auto.commit: 是否允许自动提交。
- group.id: consumer: 所在的 group。
- value.deserializer: 结果集反序列化方法，可以继承 `com.taosdata.jdbc.tmq.ReferenceDeserializer`，并指定结果集 bean，实现反序列化。也可以继承 `com.taosdata.jdbc.tmq.Deserializer`，根据 SQL 的 resultSet 自定义反序列化方式。
- httpConnectTimeout: 创建连接超时参数，单位 ms，默认为 5000 ms。仅在 WebSocket 连接下有效。
- messageWaitTimeout: 数据传输超时参数，单位 ms，默认为 10000 ms。仅在 WebSocket 连接下有效。
- httpPoolSize: 同一个连接下最大并行请求数。仅在 WebSocket 连接下有效。
- TSDBDriver.PROPERTY_KEY_ENABLE_COMPRESSION: 传输过程是否启用压缩。仅在使用 WebSocket 连接时生效。true: 启用，false: 不启用。默认为 false。
- TSDBDriver.PROPERTY_KEY_ENABLE_AUTO_RECONNECT: 是否启用自动重连。仅在使用 WebSocket 连接时生效。true: 启用，false: 不启用。默认为 false。
- TSDBDriver.PROPERTY_KEY_RECONNECT_INTERVAL_MS: 自动重连重试间隔，单位毫秒，默认值 2000。仅在 PROPERTY_KEY_ENABLE_AUTO_RECONNECT 为 true 时生效。
- TSDBDriver.PROPERTY_KEY_RECONNECT_RETRY_COUNT: 自动重连重试次数，默认值 3，仅在 PROPERTY_KEY_ENABLE_AUTO_RECONNECT 为 true 时生效。
- td.connect.type：连接方式。jni：表示使用动态库连接的方式，ws/WebSocket：表示使用 WebSocket 进行数据通信。默认为 jni 方式。
- bootstrap.servers：TDengine 服务端所在的`ip:port`，如果使用 WebSocket 连接，则为 taosAdapter 所在的`ip:port`。
- enable.auto.commit：是否允许自动提交。
- group.id：consumer：所在的 group。
- value.deserializer：结果集反序列化方法，可以继承 `com.taosdata.jdbc.tmq.ReferenceDeserializer`，并指定结果集 bean，实现反序列化。也可以继承 `com.taosdata.jdbc.tmq.Deserializer`，根据 SQL 的 resultSet 自定义反序列化方式。
- httpConnectTimeout：创建连接超时参数，单位 ms，默认为 5000 ms。仅在 WebSocket 连接下有效。
- messageWaitTimeout：数据传输超时参数，单位 ms，默认为 10000 ms。仅在 WebSocket 连接下有效。
- httpPoolSize：同一个连接下最大并行请求数。仅在 WebSocket 连接下有效。
- TSDBDriver.PROPERTY_KEY_ENABLE_COMPRESSION：传输过程是否启用压缩。仅在使用 WebSocket 连接时生效。true：启用，false：不启用。默认为 false。
- TSDBDriver.PROPERTY_KEY_ENABLE_AUTO_RECONNECT：是否启用自动重连。仅在使用 WebSocket 连接时生效。true：启用，false：不启用。默认为 false。
- TSDBDriver.PROPERTY_KEY_RECONNECT_INTERVAL_MS：自动重连重试间隔，单位毫秒，默认值 2000。仅在 PROPERTY_KEY_ENABLE_AUTO_RECONNECT 为 true 时生效。
- TSDBDriver.PROPERTY_KEY_RECONNECT_RETRY_COUNT：自动重连重试次数，默认值 3，仅在 PROPERTY_KEY_ENABLE_AUTO_RECONNECT 为 true 时生效。
其他参数请参考：[Consumer 参数列表](../../../develop/tmq/#创建参数)， 注意TDengine服务端自 3.2.0.0 版本开始消息订阅中的 auto.offset.reset 默认值发生变化。

24
docs/zh/14-reference/05-connector/26-rust.mdx
View File

@ -109,15 +109,15 @@ DSN 描述字符串基本结构如下：
各部分意义见下表：
- **driver**: 必须指定驱动名以便连接器选择何种方式创建连接，支持如下驱动名：
- **taos**: 使用 TDengine 连接器驱动，默认是使用 taos 驱动。
- **tmq**: 使用 TMQ 订阅数据。
- **protocol**: 显示指定以何种方式建立连接，例如：`taos+ws://localhost:6041` 指定以 WebSocket 方式建立连接。
- **http/ws**: 使用 WebSocket 创建连接。
- **https/wss**: 在 WebSocket 连接方式下显示启用 SSL/TLS 连接。
- **username/password**: 用于创建连接的用户名及密码。
- **host/port**: 指定创建连接的服务器及端口，当不指定服务器地址及端口时（`taos://`），原生连接默认为 `localhost:6030`，WebSocket 连接默认为 `localhost:6041` 。
- **database**: 指定默认连接的数据库名，可选参数。
- **driver**：必须指定驱动名以便连接器选择何种方式创建连接，支持如下驱动名：
- **taos**：使用 TDengine 连接器驱动，默认是使用 taos 驱动。
- **tmq**：使用 TMQ 订阅数据。
- **protocol**：显示指定以何种方式建立连接，例如：`taos+ws://localhost:6041` 指定以 WebSocket 方式建立连接。
- **http/ws**：使用 WebSocket 创建连接。
- **https/wss**：在 WebSocket 连接方式下显示启用 SSL/TLS 连接。
- **username/password**：用于创建连接的用户名及密码。
- **host/port**：指定创建连接的服务器及端口，当不指定服务器地址及端口时（`taos://`），原生连接默认为 `localhost:6030`，WebSocket 连接默认为 `localhost:6041` 。
- **database**：指定默认连接的数据库名，可选参数。
- **params**：其他可选参数。
一个完整的 DSN 描述字符串示例如下：`taos+ws://localhost:6041/test`， 表示使用 WebSocket（`ws`）方式通过 `6041` 端口连接服务器 `localhost`，并指定默认数据库为 `test`。
@ -596,6 +596,6 @@ Offset 结构体提供了获取当前消息所属的数据库，主题和分区
## 附录
- Rust 连接器文档：https://docs.rs/taos
- Rust 连接器项目地址: https://github.com/taosdata/taos-connector-rust
- deadpool 连接池: https://crates.io/crates/deadpool
- r2d2 连接池: https://crates.io/crates/r2d2
- Rust 连接器项目地址：https://github.com/taosdata/taos-connector-rust
- deadpool 连接池：https://crates.io/crates/deadpool
- r2d2 连接池：https://crates.io/crates/r2d2

170
docs/zh/14-reference/05-connector/30-python.mdx
View File

@ -168,24 +168,24 @@ TDengine 目前支持时间戳、数字、字符、布尔类型，与 Python 对
| protocol | | username | password | host | port | database | params |
```
- **protocol**: 使用 websocket 协议建立连接。例如`ws://localhost:6041`
- **username/password**: 数据库的用户名和密码。
- **host/port**: 主机地址和端口号。例如`localhost:6041`
- **database**: 数据库名称。
- **params**: 其他参数。 例如token。
- **protocol**：使用 websocket 协议建立连接。例如`ws://localhost:6041`
- **username/password**：数据库的用户名和密码。
- **host/port**：主机地址和端口号。例如`localhost:6041`
- **database**：数据库名称。
- **params**：其他参数。 例如token。
#### 建立连接
- `fn connect(dsn: Option<&str>, args: Option<&PyDict>) -> PyResult<Connection>`
- **接口说明**：建立 taosAdapter 连接。
- **参数说明**：
- `dsn`: 类型 `Option<&str>` 可选，数据源名称（DSN），用于指定要连接的数据库的位置和认证信息。
- `args`: 类型 `Option<&PyDict>` 可选，以 Python 字典的形式提供, 可用于设置
- `user`: 数据库的用户名
- `password`: 数据库的密码。
- `host`: 主机地址
- `port`: 端口号
- `database`: 数据库名称
- `dsn`：类型 `Option<&str>` 可选，数据源名称（DSN），用于指定要连接的数据库的位置和认证信息。
- `args`：类型 `Option<&PyDict>` 可选，以 Python 字典的形式提供, 可用于设置
- `user`：数据库的用户名
- `password`：数据库的密码。
- `host`：主机地址
- `port`：端口号
- `database`：数据库名称
- **返回值**：连接对象。
- **异常**：操作失败抛出 `ConnectionError` 异常。
- `fn cursor(&self) -> PyResult<Cursor>`
@ -205,7 +205,7 @@ TDengine 目前支持时间戳、数字、字符、布尔类型，与 Python 对
- **接口说明**：执行带有 req_id 的 sql 语句。
- **参数说明**：
- `sql`：待执行的 sql 语句。
- `reqId`: 用于问题追踪。
- `reqId`：用于问题追踪。
- **返回值**：影响的条数。
- **异常**：操作失败抛出 `QueryError` 异常。
- `fn query(&self, sql: &str) -> PyResult<TaosResult>`
@ -218,7 +218,7 @@ TDengine 目前支持时间戳、数字、字符、布尔类型，与 Python 对
- **接口说明**：查询带有 req_id 的 sql 语句。
- **参数说明**：
- `sql`：待执行的 sql 语句。
- `reqId`: 用于问题追踪。
- `reqId`：用于问题追踪。
- **返回值**：`TaosResult` 数据集对象。
- **异常**：操作失败抛出 `QueryError` 异常。
@ -238,11 +238,11 @@ TaosResult 对象可以通过循环遍历获取查询到的数据。
- **接口说明**：无模式写入。
- **参数说明**：
- `lines`：待写入的数据数组，无模式具体的数据格式可参考 `Schemaless 写入`。
- `protocol`: 协议类型
- `protocol`：协议类型
- `PySchemalessProtocol::Line`：InfluxDB 行协议（Line Protocol)。
- `PySchemalessProtocol::Telnet`：OpenTSDB 文本行协议。
- `PySchemalessProtocol::Json`：JSON 协议格式
- `precision`: 时间精度
- `precision`：时间精度
- `PySchemalessPrecision::Hour`：小时
- `PySchemalessPrecision::Minute`：分钟
- `PySchemalessPrecision::Second` 秒
@ -250,7 +250,7 @@ TaosResult 对象可以通过循环遍历获取查询到的数据。
- `PySchemalessPrecision::Microsecond`：微秒
- `PySchemalessPrecision::Nanosecond`：纳秒
- `ttl`：表过期时间，单位天。
- `reqId`: 用于问题追踪。
- `reqId`：用于问题追踪。
- **异常**：操作失败抛出 `DataError` 或 `OperationalError` 异常。
#### 参数绑定
@ -261,22 +261,22 @@ TaosResult 对象可以通过循环遍历获取查询到的数据。
- `fn prepare(&mut self, sql: &str) -> PyResult<()>`
- **接口说明**：绑定预编译 sql 语句。
- **参数说明**：
- `sql`: 预编译的 SQL 语句。
- `sql`：预编译的 SQL 语句。
- **异常**：操作失败抛出 `ProgrammingError` 异常。
- `fn set_tbname(&mut self, table_name: &str) -> PyResult<()>`
- **接口说明**：设置将要写入数据的表名。
- **参数说明**：
- `tableName`: 表名，如果需要指定数据库, 例如： `db_name.table_name` 即可。
- `tableName`：表名，如果需要指定数据库, 例如：`db_name.table_name` 即可。
- **异常**：操作失败抛出 `ProgrammingError` 异常。
- `fn set_tags(&mut self, tags: Vec<PyTagView>) -> PyResult<()>`
- **接口说明**：设置表 Tags 数据, 用于自动建表。
- **参数说明**：
- `paramsArray`: Tags 数据。
- `paramsArray`：Tags 数据。
- **异常**：操作失败抛出 `ProgrammingError` 异常。
- `fn bind_param(&mut self, params: Vec<PyColumnView>) -> PyResult<()>`
- **接口说明**：绑定数据。
- **参数说明**：
- `paramsArray`: 绑定数据。
- `paramsArray`：绑定数据。
- **异常**：操作失败抛出 `ProgrammingError` 异常。
- `fn add_batch(&mut self) -> PyResult<()>`
- **接口说明**：提交绑定数据。
@ -298,8 +298,8 @@ TaosResult 对象可以通过循环遍历获取查询到的数据。
- port：端口号。
- group.id：所在的 group。
- client.id：客户端id。
- td.connect.user: 数据库用户名。
- td.connect.pass: 数据库密码。
- td.connect.user：数据库用户名。
- td.connect.pass：数据库密码。
- td.connect.token：数据库的连接token。
- auto.offset.reset：来确定消费位置为最新数据（latest）还是包含旧数据（earliest）。
- enable.auto.commit：是否允许自动提交。
@ -307,14 +307,14 @@ TaosResult 对象可以通过循环遍历获取查询到的数据。
- `fn Consumer(conf: Option<&PyDict>, dsn: Option<&str>) -> PyResult<Self>`
- **接口说明** 消费者构造函数。
- `conf`: 类型 `Option<&PyDict>` 可选，以 Python 字典的形式提供, 具体配置参见属性列表。
- `dsn`: 类型 `Option<&str>` 可选，数据源名称（DSN），用于指定要连接的数据库的位置和认证信息。
- `conf`：类型 `Option<&PyDict>` 可选，以 Python 字典的形式提供, 具体配置参见属性列表。
- `dsn`：类型 `Option<&str>` 可选，数据源名称（DSN），用于指定要连接的数据库的位置和认证信息。
- **返回值**：Consumer 消费者对象。
- **异常**：操作失败抛出 `ConsumerException` 异常。
- `fn subscribe(&mut self, topics: &PyList) -> PyResult<()>`
- **接口说明** 订阅一组主题。
- **参数说明**：
- `topics`: 订阅的主题列表。
- `topics`：订阅的主题列表。
- **异常**：操作失败抛出 `ConsumerException` 异常。
- `fn unsubscribe(&mut self)`
- **接口说明** 取消订阅。
@ -322,13 +322,13 @@ TaosResult 对象可以通过循环遍历获取查询到的数据。
- `fn poll(&mut self, timeout: Option<f64>) -> PyResult<Option<Message>>`
- **接口说明** 轮询消息。
- **参数说明**：
- `timeoutMs`: 表示轮询的超时时间，单位毫秒。
- `timeoutMs`：表示轮询的超时时间，单位毫秒。
- **返回值**：`Message` 每个主题对应的数据。
- **异常**：操作失败抛出 `ConsumerException` 异常。
- `fn commit(&mut self, message: &mut Message) -> PyResult<()>`
- **接口说明** 提交当前处理的消息的偏移量。
- **参数说明**：
- `message`: 类型 `Message`, 当前处理的消息的偏移量。
- `message`：类型 `Message`, 当前处理的消息的偏移量。
- **异常**：操作失败抛出 `ConsumerException` 异常。
- `fn assignment(&mut self) -> PyResult<Option<Vec<TopicAssignment>>>`
- **接口说明**：获取消费者当前分配的指定的分区或所有分区。
@ -337,22 +337,22 @@ TaosResult 对象可以通过循环遍历获取查询到的数据。
- `fn seek(&mut self, topic: &str, vg_id: i32, offset: i64) -> PyResult<()>`
- **接口说明**：将给定分区的偏移量设置到指定的位置。
- **参数说明**：
- `topic`: 订阅的主题。
- `vg_id`: vgroupid。
- `topic`：订阅的主题。
- `vg_id`：vgroupid。
- `offset`:需要设置的偏移量。
- **异常**：操作失败抛出 ConsumerException 异常。
- `fn committed(&mut self, topic: &str, vg_id: i32) -> PyResult<i64>`
- **接口说明**：获取订阅主题的vgroupid分区最后提交的偏移量。
- **参数说明**：
- `topic`: 订阅的主题。
- `vg_id`: vgroupid。
- `topic`：订阅的主题。
- `vg_id`：vgroupid。
- **返回值**：`i64`，分区最后提交的偏移量。
- **异常**：操作失败抛出 ConsumerException 异常。
- `fn position(&mut self, topic: &str, vg_id: i32) -> PyResult<i64>`
- **接口说明**：获取给定分区当前的偏移量。
- **参数说明**：
- `topic`: 订阅的主题。
- `vg_id`: vgroupid。
- `topic`：订阅的主题。
- `vg_id`：vgroupid。
- **返回值**：`i64`，分区最后提交的偏移量。
- **异常**：操作失败抛出 ConsumerException 异常。
- `fn close(&mut self)`
@ -366,13 +366,13 @@ TaosResult 对象可以通过循环遍历获取查询到的数据。
- `def connect(*args, **kwargs):`
- **接口说明**：建立 taosAdapter 连接。
- **参数说明**：
- `kwargs`: 以 Python 字典的形式提供, 可用于设置
- `user`: 数据库的用户名
- `password`: 数据库的密码。
- `host`: 主机地址
- `port`: 端口号
- `database`: 数据库名称
- `timezone`: 时区
- `kwargs`：以 Python 字典的形式提供, 可用于设置
- `user`：数据库的用户名
- `password`：数据库的密码。
- `host`：主机地址
- `port`：端口号
- `database`：数据库名称
- `timezone`：时区
- **返回值**：`TaosConnection` 连接对象。
- **异常**：操作失败抛出 `AttributeError` 或 `ConnectionError` 异常。
- `def cursor(self)`
@ -385,14 +385,14 @@ TaosResult 对象可以通过循环遍历获取查询到的数据。
- **接口说明**：执行 sql 语句。
- **参数说明**：
- `operation`：待执行的 sql 语句。
- `reqId`: 用于问题追踪。
- `reqId`：用于问题追踪。
- **返回值**：影响的条数。
- **异常**：操作失败抛出 `ProgrammingError` 异常。
- `def query(self, sql: str, req_id: Optional[int] = None) -> TaosResult`
- **接口说明**：查询数据。
- **参数说明**：
- `sql`：待执行的 sql 语句。
- `reqId`: 用于问题追踪。
- `reqId`：用于问题追踪。
- **返回值**：`TaosResult` 数据集对象。
- **异常**：操作失败抛出 `ProgrammingError` 异常。
@ -415,11 +415,11 @@ TaosResult 对象可以通过循环遍历获取查询到的数据。
- **接口说明**：无模式写入。
- **参数说明**：
- `lines`：待写入的数据数组，无模式具体的数据格式可参考 `Schemaless 写入`。
- `protocol`: 协议类型
- `protocol`：协议类型
- `SmlProtocol.LINE_PROTOCOL`：InfluxDB 行协议（Line Protocol)。
- `SmlProtocol.TELNET_PROTOCOL`：OpenTSDB 文本行协议。
- `SmlProtocol.JSON_PROTOCOL`：JSON 协议格式
- `precision`: 时间精度
- `precision`：时间精度
- `SmlPrecision.Hour`：小时
- `SmlPrecision.Minute`：分钟
- `SmlPrecision.Second` 秒
@ -427,7 +427,7 @@ TaosResult 对象可以通过循环遍历获取查询到的数据。
- `SmlPrecision.Microsecond`：微秒
- `SmlPrecision.Nanosecond`：纳秒
- `ttl`：表过期时间，单位天。
- `reqId`: 用于问题追踪。
- `reqId`：用于问题追踪。
- **返回值**：影响的条数。
- **异常**：操作失败抛出 `SchemalessError` 异常。
@ -435,26 +435,26 @@ TaosResult 对象可以通过循环遍历获取查询到的数据。
- `def statement2(self, sql=None, option=None)`
- **接口说明**：使用连接对象创建 stmt2 对象
- **参数说明**
- `sql`: 绑定的 SQL 语句，如果不为空会调用`prepare`函数
- `sql`：绑定的 SQL 语句，如果不为空会调用`prepare`函数
- `option` 传入 TaosStmt2Option 类实例选项
- **返回值**：stmt2 对象。
- **异常**：操作失败抛出 `ConnectionError` 异常。
- `def prepare(self, sql)`
- **接口说明**：绑定预编译 sql 语句
- **参数说明**：
- `sql`: 绑定的 SQL 语句
- `sql`：绑定的 SQL 语句
- **异常**：操作失败抛出 `StatementError` 异常。
- `def bind_param(self, tbnames, tags, datas)`
- **接口说明**：以独立数组方式绑定数据
- **参数说明**：
- `tbnames`: 绑定表名数组，数据类型为 list
- `tags`: 绑定 tag 列值数组，数据类型为 list
- `tags`: 绑定普通列值数组，数据类型为 list
- `tbnames`：绑定表名数组，数据类型为 list
- `tags`：绑定 tag 列值数组，数据类型为 list
- `tags`：绑定普通列值数组，数据类型为 list
- **异常**：操作失败抛出 `StatementError` 异常
- `def bind_param_with_tables(self, tables)`
- **接口说明**：以独立表方式绑定数据，独立表是以表为组织单位，每张表中有表名，TAG 值及普通列数值属性
- **参数说明**：
- `tables`: `BindTable` 独立表对象数组
- `tables`：`BindTable` 独立表对象数组
- **异常**：操作失败抛出 `StatementError` 异常。
- `def execute(self) -> int:`
- **接口说明**：执行将绑定数据全部写入
@ -473,21 +473,21 @@ TaosResult 对象可以通过循环遍历获取查询到的数据。
- td.connect.port：端口号。
- group.id：所在的 group。
- client.id：客户端id。
- td.connect.user: 数据库用户名。
- td.connect.pass: 数据库密码。
- td.connect.user：数据库用户名。
- td.connect.pass：数据库密码。
- td.connect.token：数据库的连接token。
- auto.offset.reset：来确定消费位置为最新数据（latest）还是包含旧数据（earliest）。
- enable.auto.commit：是否允许自动提交。
- auto.commit.interval.ms：自动提交间隔
- `def Consumer(configs)`
- **接口说明** 消费者构造函数。
- `configs`: Python 字典的形式提供, 具体配置参见属性列表。
- `configs`：Python 字典的形式提供, 具体配置参见属性列表。
- **返回值**：Consumer 消费者对象。
- **异常**：操作失败抛出 `TmqError` 异常。
- `def subscribe(self, topics)`
- **接口说明** 订阅一组主题。
- **参数说明**：
- `topics`: 订阅的主题列表。
- `topics`：订阅的主题列表。
- **异常**：操作失败抛出 `TmqError` 异常。
- `def unsubscribe(self)`
- **接口说明** 取消订阅。
@ -495,14 +495,14 @@ TaosResult 对象可以通过循环遍历获取查询到的数据。
- `def poll(self, timeout: float = 1.0)`
- **接口说明** 轮询消息。
- **参数说明**：
- `timeout`: 表示轮询的超时时间，单位毫秒。
- `timeout`：表示轮询的超时时间，单位毫秒。
- **返回值**：`Message` 每个主题对应的数据。
- **异常**：操作失败抛出 `TmqError` 异常。
- `def commit(self, message: Message = None, offsets: [TopicPartition] = None)`
- **接口说明** 提交当前处理的消息的偏移量。
- **参数说明**：
- `message`: 类型 `Message`, 当前处理的消息的偏移量。
- `offsets`: 类型 `[TopicPartition]`, 提交一批消息的偏移量。
- `message`：类型 `Message`, 当前处理的消息的偏移量。
- `offsets`：类型 `[TopicPartition]`, 提交一批消息的偏移量。
- **异常**：操作失败抛出 `TmqError` 异常。
- `def assignment(self)`
- **接口说明**：获取消费者当前分配的指定的分区或所有分区。
@ -511,25 +511,25 @@ TaosResult 对象可以通过循环遍历获取查询到的数据。
- `def seek(self, partition)`
- **接口说明**：将给定分区的偏移量设置到指定的位置。
- **参数说明**：
- `partition`: 需要设置的偏移量。
- `topic`: 订阅的主题
- `partition`: 分区
- `offset`: 偏移量
- `partition`：需要设置的偏移量。
- `topic`：订阅的主题
- `partition`：分区
- `offset`：偏移量
- **异常**：操作失败抛出 `TmqError` 异常。
- `def committed(self, partitions)`
- **接口说明**：获取订阅主题的分区最后提交的偏移量。
- **参数说明**：
- `partition`: 需要设置的偏移量。
- `topic`: 订阅的主题
- `partition`: 分区
- `partition`：需要设置的偏移量。
- `topic`：订阅的主题
- `partition`：分区
- **返回值**：`partition`，分区最后提交的偏移量。
- **异常**：操作失败抛出 `TmqError` 异常。
- `def position(self, partitions)`
- **接口说明**：获取给定分区当前的偏移量。
- **参数说明**：
- `partition`: 需要设置的偏移量。
- `topic`: 订阅的主题
- `partition`: 分区
- `partition`：需要设置的偏移量。
- `topic`：订阅的主题
- `partition`：分区
- **返回值**：`partition`，分区最后提交的偏移量。
- **异常**：操作失败抛出 TmqError 异常。
- `def close(self)`
@ -541,39 +541,39 @@ TaosResult 对象可以通过循环遍历获取查询到的数据。
- `def connect(**kwargs) -> TaosRestConnection`
- **接口说明**：建立 taosAdapter 连接。
- **参数说明**：
- `kwargs`: 以 Python 字典的形式提供, 可用于设置
- `user`: 数据库的用户名
- `password`: 数据库的密码。
- `host`: 主机地址
- `port`: 端口号
- `database`: 数据库名称
- `kwargs`：以 Python 字典的形式提供, 可用于设置
- `user`：数据库的用户名
- `password`：数据库的密码。
- `host`：主机地址
- `port`：端口号
- `database`：数据库名称
- **返回值**：连接对象。
- **异常**：操作失败抛出 `ConnectError` 异常。
- `def execute(self, sql: str, req_id: Optional[int] = None) -> Optional[int]`
- **接口说明**：执行 sql 语句。
- **参数说明**：
- `sql`：待执行的 sql 语句。
- `reqId`: 用于问题追踪。
- `reqId`：用于问题追踪。
- **返回值**：影响的条数。
- **异常**：操作失败抛出 `ConnectError` 或 `HTTPError` 异常。
- `def query(self, sql: str, req_id: Optional[int] = None) -> Result`
- **接口说明**：查询数据。
- **参数说明**：
- `sql`：待执行的 sql 语句。
- `reqId`: 用于问题追踪。
- `reqId`：用于问题追踪。
- **返回值**：`Result` 数据集对象。
- **异常**：操作失败抛出 `ConnectError` 或 `HTTPError` 异常。
- `RestClient(self, url: str, token: str = None, database: str = None, user: str = "root", password: str = "taosdata", timeout: int = None, convert_timestamp: bool = True, timezone: Union[str, datetime.tzinfo] = None)`
- **接口说明**：建立 taosAdapter 连接 client。
- **参数说明**：
- `url`: taosAdapter REST 服务的 URL。
- `user`: 数据库的用户名。
- `password`: 数据库的密码。
- `database`: 数据库名称。
- `timezone`: 时区。
- `timeout`: HTTP 请求超时时间。单位为秒。
- `convert_timestamp`: 是否将时间戳从STR类型转换为datetime类型。
- `timezone`: 时区.
- `url`：taosAdapter REST 服务的 URL。
- `user`：数据库的用户名。
- `password`：数据库的密码。
- `database`：数据库名称。
- `timezone`：时区。
- `timeout`：HTTP 请求超时时间。单位为秒。
- `convert_timestamp`：是否将时间戳从STR类型转换为datetime类型。
- `timezone`：时区.
- **返回值**：连接对象。
- **异常**：操作失败抛出 `ConnectError` 异常。
- `def sql(self, q: str, req_id: Optional[int] = None) -> dict`

72
docs/zh/14-reference/05-connector/35-node.mdx
View File

@ -116,11 +116,11 @@ Node.js 连接器（`@tdengine/websocket`）, 其通过 taosAdapter 提供的 We
| protocol | | username | password | host | port | database | params |
```
- **protocol**: 使用 websocket 协议建立连接。例如`ws://localhost:6041`
- **username/password**: 数据库的用户名和密码。
- **host/port**: 主机地址和端口号。例如`localhost:6041`
- **database**: 数据库名称。
- **params**: 其他参数。 例如token。
- **protocol**：使用 websocket 协议建立连接。例如`ws://localhost:6041`
- **username/password**：数据库的用户名和密码。
- **host/port**：主机地址和端口号。例如`localhost:6041`
- **database**：数据库名称。
- **params**：其他参数。 例如token。
- 完整 URL 示例：
@ -180,7 +180,7 @@ WSConfig 中的配置如下：
- **接口说明**：执行 sql 语句。
- **参数说明**：
- `sql`：待执行的 sql 语句。
- `reqId`: 请求 id 非必填，用于问题追踪。
- `reqId`：请求 id 非必填，用于问题追踪。
- **返回值**：执行结果
```js
TaosResult {
@ -194,7 +194,7 @@ WSConfig 中的配置如下：
- **接口说明**：查询数据。
- **参数说明**：
- `sql`：待执行的查询 sql 语句。
- `reqId`: 请求 id 非必填，用于问题追踪。
- `reqId`：请求 id 非必填，用于问题追踪。
- **返回值**：WSRows 数据集对象。
- **异常**：连接失败抛出 `TDWebSocketClientError` 异常。
@ -225,11 +225,11 @@ WSConfig 中的配置如下：
- **接口说明**：无模式写入。
- **参数说明**：
- `lines`：待写入的数据数组，无模式具体的数据格式可参考 `Schemaless 写入`。
- `protocol`: 协议类型
- `protocol`：协议类型
- `SchemalessProto.InfluxDBLineProtocol`：InfluxDB 行协议（Line Protocol)。
- `SchemalessProto.OpenTSDBTelnetLineProtocol`：OpenTSDB 文本行协议。
- `SchemalessProto.OpenTSDBJsonFormatProtocol`：JSON 协议格式。
- `precision`: 时间精度
- `precision`：时间精度
- `Precision.HOURS`：小时
- `Precision.MINUTES`：分钟
- `Precision.SECONDS`：秒
@ -237,31 +237,31 @@ WSConfig 中的配置如下：
- `Precision.MICRO_SECONDS`：微秒
- `Precision.NANO_SECONDS`：纳秒
- `ttl`：表过期时间，单位天。
- `reqId`: 用于问题追踪，可选。
- `reqId`：用于问题追踪，可选。
- **异常**：连接失败抛出 `TaosResultError` 异常。
### 参数绑定
- `async stmtInit(reqId?:number): Promise<WsStmt>`
- **接口说明** 使用 WsSql 对象创建 stmt 对象。
- **参数说明**：
- `reqId`: 请求 id 非必填，用于问题追踪。
- `reqId`：请求 id 非必填，用于问题追踪。
- **返回值**：stmt 对象。
- **异常**：连接失败抛出 `TDWebSocketClientError` 异常。
- `async prepare(sql: string): Promise<void>`
- **接口说明** 绑定预编译 sql 语句。
- **参数说明**：
- `sql`: 预编译的 SQL 语句。
- `sql`：预编译的 SQL 语句。
- **异常**：连接失败抛出 `TDWebSocketClientError` 异常。
- `async setTableName(tableName: string): Promise<void>`
- **接口说明** 设置将要写入数据的表名。
- **参数说明**：
- `tableName`: 表名，如果需要指定数据库, 例如： `db_name.table_name` 即可。
- `tableName`：表名，如果需要指定数据库, 例如：`db_name.table_name` 即可。
- **异常**：连接失败抛出 `TDWebSocketClientError` 异常。
通过 StmtBindParams 对象设置绑定数据。
- `setBoolean(params :any[])`
- **接口说明** 设置布尔值。
- **参数说明**：
- `params`: 布尔类型列表。
- `params`：布尔类型列表。
- **异常**：连接失败抛出 `TDWebSocketClientError` 异常。
- 下面接口除了要设置的值类型不同外，其余同 setBoolean：
- `setTinyInt(params :any[])`
@ -284,12 +284,12 @@ WSConfig 中的配置如下：
- `async setTags(paramsArray:StmtBindParams): Promise<void>`
- **接口说明** 设置表 Tags 数据，用于自动建表。
- **参数说明**：
- `paramsArray`: Tags 数据。
- `paramsArray`：Tags 数据。
- **异常**：连接失败抛出 `TDWebSocketClientError` 异常。
- `async bind(paramsArray:StmtBindParams): Promise<void>`
- **接口说明** 绑定数据。
- **参数说明**：
- `paramsArray`: 绑定数据。
- `paramsArray`：绑定数据。
- **异常**：连接失败抛出 `TDWebSocketClientError` 异常。
- `async batch(): Promise<void>`
- **接口说明** 提交绑定数据。
@ -307,69 +307,69 @@ WSConfig 中的配置如下：
### 数据订阅
- **创建消费者支持属性列表**：
- taos.TMQConstants.CONNECT_USER: 用户名。
- taos.TMQConstants.CONNECT_PASS: 密码。
- taos.TMQConstants.GROUP_ID: 所在的 group。
- taos.TMQConstants.CLIENT_ID: 客户端id。
- taos.TMQConstants.WS_URL: taosAdapter 的url地址。
- taos.TMQConstants.AUTO_OFFSET_RESET: 来确定消费位置为最新数据（latest）还是包含旧数据（earliest）。
- taos.TMQConstants.ENABLE_AUTO_COMMIT: 是否允许自动提交。
- taos.TMQConstants.AUTO_COMMIT_INTERVAL_MS: 自动提交间隔。
- taos.TMQConstants.CONNECT_MESSAGE_TIMEOUT: 数据传输超时参数，单位 ms，默认为 10000 ms。
- taos.TMQConstants.CONNECT_USER：用户名。
- taos.TMQConstants.CONNECT_PASS：密码。
- taos.TMQConstants.GROUP_ID：所在的 group。
- taos.TMQConstants.CLIENT_ID：客户端id。
- taos.TMQConstants.WS_URL：taosAdapter 的url地址。
- taos.TMQConstants.AUTO_OFFSET_RESET：来确定消费位置为最新数据（latest）还是包含旧数据（earliest）。
- taos.TMQConstants.ENABLE_AUTO_COMMIT：是否允许自动提交。
- taos.TMQConstants.AUTO_COMMIT_INTERVAL_MS：自动提交间隔。
- taos.TMQConstants.CONNECT_MESSAGE_TIMEOUT：数据传输超时参数，单位 ms，默认为 10000 ms。
- `static async newConsumer(wsConfig:Map<string, any>):Promise<WsConsumer>`
- **接口说明** 消费者构造函数。
- **参数说明**：
- `wsConfig`: 创建消费者属性配置。
- `wsConfig`：创建消费者属性配置。
- **返回值**：WsConsumer 消费者对象。
- **异常**：如果在执行过程中出现异常，抛出 `TDWebSocketClientError` 错误。
- `async subscribe(topics: Array<string>, reqId?:number): Promise<void>`
- **接口说明** 订阅一组主题。
- **参数说明**：
- `topics`: 订阅的主题列表。
- `reqId`: 请求 id 非必填，用于问题追踪。
- `topics`：订阅的主题列表。
- `reqId`：请求 id 非必填，用于问题追踪。
- **异常**：失败抛出 `TDWebSocketClientError` 异常。
- `async unsubscribe(reqId?:number): Promise<void>`
- **接口说明** 取消订阅。
- **参数说明**：
- `reqId`: 请求 id 非必填，用于问题追踪。
- `reqId`：请求 id 非必填，用于问题追踪。
- **异常**：失败抛出 `TDWebSocketClientError` 异常。
- `async poll(timeoutMs: number, reqId?:number):Promise<Map<string, TaosResult>>`
- **接口说明** 轮询消息。
- **参数说明**：
- `timeoutMs`: 表示轮询的超时时间，单位毫秒。
- `reqId`: 请求 id 非必填，用于问题追踪。
- `timeoutMs`：表示轮询的超时时间，单位毫秒。
- `reqId`：请求 id 非必填，用于问题追踪。
- **返回值**：`Map<string, TaosResult>` 每个主题对应的数据。
- **异常**：失败抛出 `TDWebSocketClientError` 异常。
- `async subscription(reqId?:number):Promise<Array<string>>`
- **接口说明** 获取当前订阅的所有主题。
- **参数说明**：
- `reqId`: 请求 id 非必填，用于问题追踪。
- `reqId`：请求 id 非必填，用于问题追踪。
- **返回值**：`Array<string>` 主题列表。
- **异常**：失败抛出 `TDWebSocketClientError` 异常。
- `async commit(reqId?:number):Promise<Array<TopicPartition>>`
- **接口说明** 提交当前处理的消息的偏移量。
- **参数说明**：
- `reqId`: 请求 id 非必填，用于问题追踪。
- `reqId`：请求 id 非必填，用于问题追踪。
- **返回值**：`Array<TopicPartition>` 每个主题的消费进度。
- **异常**：失败抛出 `TDWebSocketClientError` 异常。
- `async committed(partitions:Array<TopicPartition>, reqId?:number):Promise<Array<TopicPartition>>`
- **接口说明**：获取一组分区最后提交的偏移量。
- **参数说明**：
- `partitions`：一个 `Array<TopicPartition>` 类型的参数，表示要查询的分区集合。
- `reqId`: 请求 id 非必填，用于问题追踪。
- `reqId`：请求 id 非必填，用于问题追踪。
- **返回值**：`Array<TopicPartition>`，即一组分区最后提交的偏移量。
- **异常**：如果在获取提交的偏移量过程中发生错误，将抛出 `TDWebSocketClientError` 异常。
- `async seek(partition:TopicPartition, reqId?:number):Promise<void>`
- **接口说明**：将给定分区的偏移量设置到指定的位置。
- **参数说明**：
- `partition`：一个 `TopicPartition` 类型的参数，表示要操作的分区和要设置的偏移量。
- `reqId`: 请求 id 非必填，用于问题追踪。
- `reqId`：请求 id 非必填，用于问题追踪。
- **异常**：如果在设置偏移量过程中发生错误，将抛出 `TDWebSocketClientError` 异常。
- `async positions(partitions:Array<TopicPartition>, reqId?:number):Promise<Array<TopicPartition>>`
- **接口说明**：获取给定分区当前的偏移量。
- **参数说明**：
- `partitions`：一个 `TopicPartition` 类型的参数，表示要查询的分区。
- `reqId`: 请求 id 非必填，用于问题追踪。
- `reqId`：请求 id 非必填，用于问题追踪。
- **返回值**：`Array<TopicPartition>`，即一组分区最后提交的偏移量。
- **异常**：如果在获取偏移量过程中发生错误，将抛出 `TDWebSocketClientError` 异常。
- `async seekToBeginning(partitions:Array<TopicPartition>):Promise<void>`

6
docs/zh/14-reference/05-connector/45-php.mdx
View File

@ -18,8 +18,8 @@ TDengine 服务端或客户端安装后，`taos.h` 位于：
TDengine 客户端驱动的动态库位于：
- Linux: `/usr/local/taos/driver/libtaos.so`
- Windows: `C:\TDengine\taos.dll`
- Linux：`/usr/local/taos/driver/libtaos.so`
- Windows：`C:\TDengine\taos.dll`
- macOS：`/usr/local/lib/libtaos.dylib`
## 支持的平台
@ -85,7 +85,7 @@ phpize && ./configure --enable-swoole && make -j && make install
本节展示了使用客户端驱动访问 TDengine 集群的常见访问方式的示例代码。
> 所有错误都会抛出异常: `TDengine\Exception\TDengineException`
> 所有错误都会抛出异常：`TDengine\Exception\TDengineException`
### 建立连接

580
docs/zh/14-reference/05-connector/50-odbc.mdx
View File

@ -52,11 +52,11 @@ TDengine ODBC 支持两种连接 TDengine 数据库方式：WebSocket 连接与
![ODBC WebSocket connection config](./assets/odbc-ws-config-zh.webp)
4.1 【DSN】:Data Source Name 必填，为新添加的 ODBC 数据源命名
4.1 【DSN】：Data Source Name 必填，为新添加的 ODBC 数据源命名
4.2【连接类型】 : 必选，选择连接类型，这里选择 【WebSocket】
4.2【连接类型】：必选，选择连接类型，这里选择 【WebSocket】
4.3【URL】必填，ODBC 数据源 URL，示例: `http://localhost:6041`， 云服务的 url 示例: `https://gw.cloud.taosdata.com?token=your_token`
4.3【URL】必填，ODBC 数据源 URL，示例：`http://localhost:6041`， 云服务的 url 示例：`https://gw.cloud.taosdata.com?token=your_token`
4.4【数据库】选填，需要连接的默认数据库
@ -84,11 +84,11 @@ TDengine ODBC 支持两种连接 TDengine 数据库方式：WebSocket 连接与
![ODBC native connection config](./assets/odbc-native-config-zh.webp)
4.1 【DSN】:Data Source Name 必填，为新添加的 ODBC 数据源命名
4.1 【DSN】：Data Source Name 必填，为新添加的 ODBC 数据源命名
4.2 【连接类型】 : 必选，选择连接类型，这里选择 【Native】 原生连接；
4.2 【连接类型】：必选，选择连接类型，这里选择 【Native】 原生连接；
4.3 【服务器】必填，ODBC 数据源 服务器 地址，示例: `localhost:6030`
4.3 【服务器】必填，ODBC 数据源 服务器 地址，示例：`localhost:6030`
4.4 【数据库】选填，需要连接的默认数据库
@ -267,388 +267,388 @@ TDengine ODBC 支持两种连接 TDengine 数据库方式：WebSocket 连接与
#### 数据源和驱动程序管理
- API: ConfigDSN
- **是否支持**: 支持（仅 Windows）
- **标准**: ODBC
- **作用**: 配置数据源
- API：ConfigDSN
- **是否支持**：支持（仅 Windows）
- **标准**：ODBC
- **作用**：配置数据源
- API: ConfigDriver
- **是否支持**: 支持（仅 Windows）
- **标准**: ODBC
- **作用**: 用于执行与特定驱动程序相关的安装和配置任务
- API：ConfigDriver
- **是否支持**：支持（仅 Windows）
- **标准**：ODBC
- **作用**：用于执行与特定驱动程序相关的安装和配置任务
- API: ConfigTranslator
- **是否支持**: 不支持
- **标准**: ODBC
- **作用**: 用于解析DSN的配置，在DSN配置和实际数据库驱动程序配置之间进行翻译或转换
- API：ConfigTranslator
- **是否支持**：不支持
- **标准**：ODBC
- **作用**：用于解析DSN的配置，在DSN配置和实际数据库驱动程序配置之间进行翻译或转换
#### 连接到数据源
- API: SQLAllocHandle
- **是否支持**: 支持
- **标准**: ISO 92
- **作用**: 分配环境、连接、语句或描述符句柄
- API：SQLAllocHandle
- **是否支持**：支持
- **标准**：ISO 92
- **作用**：分配环境、连接、语句或描述符句柄
- API: SQLConnect
- **是否支持**: 支持
- **标准**: ISO 92
- **作用**: 通过数据源名称、用户 ID 和密码连接到特定驱动程序
- API：SQLConnect
- **是否支持**：支持
- **标准**：ISO 92
- **作用**：通过数据源名称、用户 ID 和密码连接到特定驱动程序
- API: SQLDriverConnect
- **是否支持**: 支持
- **标准**: ODBC
- **作用**: 通过连接字符串连接到特定驱动程序，支持更多连接信息
- API：SQLDriverConnect
- **是否支持**：支持
- **标准**：ODBC
- **作用**：通过连接字符串连接到特定驱动程序，支持更多连接信息
- API: SQLBrowseConnect
- **是否支持**: 不支持
- **标准**: ODBC
- **作用**: 用于发现和枚举连接到数据源所需的特性和属性值。每次调用 SQLBrowseConnect 都会返回属性和属性值的连续级别
- API：SQLBrowseConnect
- **是否支持**：不支持
- **标准**：ODBC
- **作用**：用于发现和枚举连接到数据源所需的特性和属性值。每次调用 SQLBrowseConnect 都会返回属性和属性值的连续级别
- API: SQLAllocEnv
- **是否支持**: 不支持
- **标准**: 弃用
- **作用**: 在 ODBC 3.x 中，ODBC 2.x 函数 SQLAllocEnv 已替换为 SQLAllocHandle
- API：SQLAllocEnv
- **是否支持**：不支持
- **标准**：弃用
- **作用**：在 ODBC 3.x 中，ODBC 2.x 函数 SQLAllocEnv 已替换为 SQLAllocHandle
- API: SQLAllocConnect
- **是否支持**: 不支持
- **标准**: 弃用
- **作用**: 在 ODBC 3.x 中，ODBC 2.x 函数 SQLAllocConnect 已替换为 SQLAllocHandle
- API：SQLAllocConnect
- **是否支持**：不支持
- **标准**：弃用
- **作用**：在 ODBC 3.x 中，ODBC 2.x 函数 SQLAllocConnect 已替换为 SQLAllocHandle
#### 获取有关驱动程序和数据源的信息
- API: SQLDataSources
- **是否支持**: 不支持
- **标准**: ISO 92
- **作用**: 返回可用数据源的列表，由驱动程序管理器处理
- API：SQLDataSources
- **是否支持**：不支持
- **标准**：ISO 92
- **作用**：返回可用数据源的列表，由驱动程序管理器处理
- API: SQLDrivers
- **是否支持**: 不支持
- **标准**: ISO 92
- **作用**: 返回由驱动程序管理器处理的已安装驱动程序及其属性的列表
- API：SQLDrivers
- **是否支持**：不支持
- **标准**：ISO 92
- **作用**：返回由驱动程序管理器处理的已安装驱动程序及其属性的列表
- API: SQLGetInfo
- **是否支持**: 支持
- **标准**: ISO 92
- **作用**: 返回有关数据库环境的详细信息，如数据库产品名称、驱动程序名、数据库的SQL语法特性、连接能力等等
- API：SQLGetInfo
- **是否支持**：支持
- **标准**：ISO 92
- **作用**：返回有关数据库环境的详细信息，如数据库产品名称、驱动程序名、数据库的SQL语法特性、连接能力等等
- API: SQLGetFunctions
- **是否支持**: 不支持
- **标准**: ISO 92
- **作用**: 用于查询驱动程序支持的函数
- API：SQLGetFunctions
- **是否支持**：不支持
- **标准**：ISO 92
- **作用**：用于查询驱动程序支持的函数
- API: SQLGetTypeInfo
- **是否支持**: 支持
- **标准**: ISO 92
- **作用**: 返回有关支持的数据类型的信息
- API：SQLGetTypeInfo
- **是否支持**：支持
- **标准**：ISO 92
- **作用**：返回有关支持的数据类型的信息
#### 设置和检索驱动程序属性
- API: SQLSetConnectAttr
- **是否支持**: 支持
- **标准**: ISO 92
- **作用**: 设置连接属性，当设置SQL_ATTR_AUTOCOMMIT属性时，用于控制自动提交模式
- API：SQLSetConnectAttr
- **是否支持**：支持
- **标准**：ISO 92
- **作用**：设置连接属性，当设置SQL_ATTR_AUTOCOMMIT属性时，用于控制自动提交模式
- API: SQLGetConnectAttr
- **是否支持**: 支持
- **标准**: ISO 92
- **作用**: 返回连接属性的值
- API：SQLGetConnectAttr
- **是否支持**：支持
- **标准**：ISO 92
- **作用**：返回连接属性的值
- API: SQLSetConnectOption
- **是否支持**: 不支持
- **标准**: 弃用
- **作用**: 在 ODBC 3.x 中，ODBC 2.0 函数 SQLSetConnectOption 已替换为 SQLSetConnectAttr
- API：SQLSetConnectOption
- **是否支持**：不支持
- **标准**：弃用
- **作用**：在 ODBC 3.x 中，ODBC 2.0 函数 SQLSetConnectOption 已替换为 SQLSetConnectAttr
- API: SQLGetConnectOption
- **是否支持**: 不支持
- **标准**: 弃用
- **作用**: 在 ODBC 3.x 中，ODBC 2.0 函数 SQLSetConnectOption 已替换为 SQLGetConnectAttr
- API：SQLGetConnectOption
- **是否支持**：不支持
- **标准**：弃用
- **作用**：在 ODBC 3.x 中，ODBC 2.0 函数 SQLSetConnectOption 已替换为 SQLGetConnectAttr
- API: SQLSetEnvAttr
- **是否支持**: 支持
- **标准**: ISO 92
- **作用**: 设置控制环境的属性
- API：SQLSetEnvAttr
- **是否支持**：支持
- **标准**：ISO 92
- **作用**：设置控制环境的属性
- API: SQLGetEnvAttr
- **是否支持**: 支持
- **标准**: ISO 92
- **作用**: 返回环境属性的当前设置
- API：SQLGetEnvAttr
- **是否支持**：支持
- **标准**：ISO 92
- **作用**：返回环境属性的当前设置
- API: SQLSetStmtAttr
- **是否支持**: 支持
- **标准**: ISO 92
- **作用**: 设置与语句相关的属性
- API：SQLSetStmtAttr
- **是否支持**：支持
- **标准**：ISO 92
- **作用**：设置与语句相关的属性
- API: SQLGetStmtAttr
- **是否支持**: 支持
- **标准**: ISO 92
- **作用**: 返回语句属性的当前设置
- API：SQLGetStmtAttr
- **是否支持**：支持
- **标准**：ISO 92
- **作用**：返回语句属性的当前设置
- API: SQLSetStmtOption
- **是否支持**: 不支持
- **标准**: 弃用
- **作用**: 在 ODBC 3.x 中，ODBC 2.0 函数 SQLSetStmtOption 已替换为 SQLSetStmtAttr
- API：SQLSetStmtOption
- **是否支持**：不支持
- **标准**：弃用
- **作用**：在 ODBC 3.x 中，ODBC 2.0 函数 SQLSetStmtOption 已替换为 SQLSetStmtAttr
- API: SQLGetStmtOption
- **是否支持**: 不支持
- **标准**: 弃用
- **作用**: 在 ODBC 3.x 中，ODBC 2.0 函数 SQLSetStmtOption 已替换为 SQLGetStmtAttr
- API：SQLGetStmtOption
- **是否支持**：不支持
- **标准**：弃用
- **作用**：在 ODBC 3.x 中，ODBC 2.0 函数 SQLSetStmtOption 已替换为 SQLGetStmtAttr
#### 准备 SQL 请求
- API: SQLAllocStmt
- **是否支持**: 不支持
- **标准**: 弃用
- **作用**: 在 ODBC 3.x 中，ODBC 2.x 函数 SQLAllocStmt 已替换为 SQLAllocHandle
- API：SQLAllocStmt
- **是否支持**：不支持
- **标准**：弃用
- **作用**：在 ODBC 3.x 中，ODBC 2.x 函数 SQLAllocStmt 已替换为 SQLAllocHandle
- API: SQLPrepare
- **是否支持**: 支持
- **标准**: ISO 92
- **作用**: 用于预处理SQL语句，这通常是SQLExecute之前的一个步骤
- API：SQLPrepare
- **是否支持**：支持
- **标准**：ISO 92
- **作用**：用于预处理SQL语句，这通常是SQLExecute之前的一个步骤
- API: SQLBindCol
- **是否支持**: 支持
- **标准**: ODBC
- **作用**: 用于将结果集中的列绑定到应用程序缓冲区
- API：SQLBindCol
- **是否支持**：支持
- **标准**：ODBC
- **作用**：用于将结果集中的列绑定到应用程序缓冲区
- API: SQLBindParameter
- **是否支持**: 支持
- **标准**: ODBC
- **作用**: 用于将SQL语句的参数绑定到应用程序缓冲区
- API：SQLBindParameter
- **是否支持**：支持
- **标准**：ODBC
- **作用**：用于将SQL语句的参数绑定到应用程序缓冲区
- API: SQLGetCursorName
- **是否支持**: 不支持
- **标准**: ISO 92
- **作用**: 返回与指定语句关联的游标名称
- API：SQLGetCursorName
- **是否支持**：不支持
- **标准**：ISO 92
- **作用**：返回与指定语句关联的游标名称
- API: SQLSetCursorName
- **是否支持**: 不支持
- **标准**: ISO 92
- **作用**: 设置游标名称，允许在查询中使用命名游标
- API：SQLSetCursorName
- **是否支持**：不支持
- **标准**：ISO 92
- **作用**：设置游标名称，允许在查询中使用命名游标
- API: SQLSetScrollOptions
- **是否支持**: 不支持
- **标准**: ODBC
- **作用**: 设置控制光标行为的选项
- API：SQLSetScrollOptions
- **是否支持**：不支持
- **标准**：ODBC
- **作用**：设置控制光标行为的选项
#### 提交请求
- API: SQLExecute
- **是否支持**: 支持
- **标准**: ISO 92
- **作用**: 用于执行之前通过 SQLPrepare 准备好的SQL语句
- API：SQLExecute
- **是否支持**：支持
- **标准**：ISO 92
- **作用**：用于执行之前通过 SQLPrepare 准备好的SQL语句
- API: SQLExecDirect
- **是否支持**: 支持
- **标准**: ISO 92
- **作用**: 用于执行包含SQL语句的字符串
- API：SQLExecDirect
- **是否支持**：支持
- **标准**：ISO 92
- **作用**：用于执行包含SQL语句的字符串
- API: SQLNativeSql
- **是否支持**: 不支持
- **标准**: ODBC
- **作用**: 用于将应用程序提供的SQL语句转换为数据库驱动程序的本机SQL语法
- API：SQLNativeSql
- **是否支持**：不支持
- **标准**：ODBC
- **作用**：用于将应用程序提供的SQL语句转换为数据库驱动程序的本机SQL语法
- API: SQLDescribeParam
- **是否支持**: 支持
- **标准**: ODBC
- **作用**: 返回语句中特定参数的描述
- API：SQLDescribeParam
- **是否支持**：支持
- **标准**：ODBC
- **作用**：返回语句中特定参数的描述
- API: SQLNumParams
- **是否支持**: 支持
- **标准**: ISO 92
- **作用**: 用于查询预编译SQL语句中的参数数量
- API：SQLNumParams
- **是否支持**：支持
- **标准**：ISO 92
- **作用**：用于查询预编译SQL语句中的参数数量
- API: SQLParamData
- **是否支持**: 不支持
- **标准**: ISO 92
- **作用**: 用于从参数数据流中获取下一个参数值
- API：SQLParamData
- **是否支持**：不支持
- **标准**：ISO 92
- **作用**：用于从参数数据流中获取下一个参数值
- API: SQLPutData
- **是否支持**: 不支持
- **标准**: ISO 92
- **作用**: 当使用流输入方式时，可以用于向输出参数发送数据块
- API：SQLPutData
- **是否支持**：不支持
- **标准**：ISO 92
- **作用**：当使用流输入方式时，可以用于向输出参数发送数据块
#### 检索结果和关于结果的信息
- API: SQLRowCount
- **是否支持**: 支持
- **标准**: ISO 92
- **作用**: 返回受插入或删除请求影响的行数
- API：SQLRowCount
- **是否支持**：支持
- **标准**：ISO 92
- **作用**：返回受插入或删除请求影响的行数
- API: SQLNumResultCols
- **是否支持**: 支持
- **标准**: ISO 92
- **作用**: 返回结果集中的列数
- API：SQLNumResultCols
- **是否支持**：支持
- **标准**：ISO 92
- **作用**：返回结果集中的列数
- API: SQLDescribeCol
- **是否支持**: 支持
- **标准**: ISO 92
- **作用**: 用于描述结果集中列的属性。它提供了关于列的数据类型、列名、列的最大宽度、小数位数和是否可为空等信息
- API：SQLDescribeCol
- **是否支持**：支持
- **标准**：ISO 92
- **作用**：用于描述结果集中列的属性。它提供了关于列的数据类型、列名、列的最大宽度、小数位数和是否可为空等信息
- API: SQLColAttribute
- **是否支持**: 支持
- **标准**: ISO 92
- **作用**: 返回结果集中列的描述符信息，如标题、排序规则等
- API：SQLColAttribute
- **是否支持**：支持
- **标准**：ISO 92
- **作用**：返回结果集中列的描述符信息，如标题、排序规则等
- API: SQLColAttributes
- **是否支持**: 不支持
- **标准**: 弃用
- **作用**: 在 ODBC 3.x 中，ODBC 2.0 函数 SQLColAttributes 已替换为 SQLColAttribute
- API：SQLColAttributes
- **是否支持**：不支持
- **标准**：弃用
- **作用**：在 ODBC 3.x 中，ODBC 2.0 函数 SQLColAttributes 已替换为 SQLColAttribute
- API: SQLGetData
- **是否支持**: 支持
- **标准**: ODBC
- **作用**: 用于从结果集中的当前行获取特定列的数据
- API：SQLGetData
- **是否支持**：支持
- **标准**：ODBC
- **作用**：用于从结果集中的当前行获取特定列的数据
- API: SQLMoreResults
- **是否支持**: 支持
- **标准**: ODBC
- **作用**: 多个结果集的 SQL 语句执行后（例如：一个批处理或存储过程），移动到下一个结果集
- API：SQLMoreResults
- **是否支持**：支持
- **标准**：ODBC
- **作用**：多个结果集的 SQL 语句执行后（例如：一个批处理或存储过程），移动到下一个结果集
- API: SQLFetch
- **是否支持**: 支持
- **标准**: ISO 92
- **作用**: 用于从结果集中提取下一行数据，并返回所有绑定列的数据
- API：SQLFetch
- **是否支持**：支持
- **标准**：ISO 92
- **作用**：用于从结果集中提取下一行数据，并返回所有绑定列的数据
- API: SQLFetchScroll
- **是否支持**: 支持
- **标准**: ISO 92
- **作用**: 用于从结果集中提取指定的数据行集，并返回所有绑定列的数据
- API：SQLFetchScroll
- **是否支持**：支持
- **标准**：ISO 92
- **作用**：用于从结果集中提取指定的数据行集，并返回所有绑定列的数据
- API: SQLExtendedFetch
- **是否支持**: 不支持
- **标准**: 弃用
- **作用**: 在 ODBC 3.x 中，SQLExtendedFetch 已替换为 SQLFetchScroll
- API：SQLExtendedFetch
- **是否支持**：不支持
- **标准**：弃用
- **作用**：在 ODBC 3.x 中，SQLExtendedFetch 已替换为 SQLFetchScroll
- API: SQLSetPos
- **是否支持**: 支持
- **标准**: ODBC
- **作用**: 设置行集中的游标位置，并允许应用程序更新数据集中的行
- API：SQLSetPos
- **是否支持**：支持
- **标准**：ODBC
- **作用**：设置行集中的游标位置，并允许应用程序更新数据集中的行
- API: SQLBulkOperations
- **是否支持**: 不支持
- **标准**: ODBC
- **作用**: 执行批量插入和批量书签操作，包括更新、删除和按书签提取
- API：SQLBulkOperations
- **是否支持**：不支持
- **标准**：ODBC
- **作用**：执行批量插入和批量书签操作，包括更新、删除和按书签提取
#### 检索错误或诊断信息
- API: SQLError
- **是否支持**: 不支持
- **标准**: 弃用
- **作用**: 在 ODBC 3.x 中，ODBC 2.x 函数 SQLError 已替换为 SQLGetDiagRec
- API：SQLError
- **是否支持**：不支持
- **标准**：弃用
- **作用**：在 ODBC 3.x 中，ODBC 2.x 函数 SQLError 已替换为 SQLGetDiagRec
- API: SQLGetDiagField
- **是否支持**: 支持
- **标准**: ISO 92
- **作用**: 返回附加诊断信息（单条诊断结果）
- API：SQLGetDiagField
- **是否支持**：支持
- **标准**：ISO 92
- **作用**：返回附加诊断信息（单条诊断结果）
- API: SQLGetDiagRec
- **是否支持**: 支持
- **标准**: ISO 92
- **作用**: 返回附加诊断信息（多条诊断结果）
- API：SQLGetDiagRec
- **是否支持**：支持
- **标准**：ISO 92
- **作用**：返回附加诊断信息（多条诊断结果）
#### 获取有关数据源的系统表项的信息
- API: SQLColumnPrivileges
- **是否支持**: 不支持
- **标准**: ODBC
- **作用**: 用于检索指定表中列的权限信息，如哪些用户或角色拥有对特定列的读取、插入、更新或删除权限
- API：SQLColumnPrivileges
- **是否支持**：不支持
- **标准**：ODBC
- **作用**：用于检索指定表中列的权限信息，如哪些用户或角色拥有对特定列的读取、插入、更新或删除权限
- API: SQLColumns
- **是否支持**: 支持
- **标准**: X/Open
- **作用**: 返回指定表中的列名列表
- API：SQLColumns
- **是否支持**：支持
- **标准**：X/Open
- **作用**：返回指定表中的列名列表
- API: SQLForeignKeys
- **是否支持**: 不支持
- **标准**: ODBC
- **作用**: 检索外键关系的详细信息
- API：SQLForeignKeys
- **是否支持**：不支持
- **标准**：ODBC
- **作用**：检索外键关系的详细信息
- API: SQLPrimaryKeys
- **是否支持**: 支持
- **标准**: ODBC
- **作用**: 返回构成表主键的列名列表
- API：SQLPrimaryKeys
- **是否支持**：支持
- **标准**：ODBC
- **作用**：返回构成表主键的列名列表
- API: SQLSpecialColumns
- **是否支持**: 不支持
- **标准**: X/Open
- **作用**: 返回数据库中特殊列的信息，如唯一键或索引列
- API：SQLSpecialColumns
- **是否支持**：不支持
- **标准**：X/Open
- **作用**：返回数据库中特殊列的信息，如唯一键或索引列
- API: SQLStatistics
- **是否支持**: 不支持
- **标准**: ISO 92
- **作用**: 返回关于表的统计信息，如行数、列数、平均行宽等
- API：SQLStatistics
- **是否支持**：不支持
- **标准**：ISO 92
- **作用**：返回关于表的统计信息，如行数、列数、平均行宽等
- API: SQLTablePrivileges
- **是否支持**: 不支持
- **标准**: ODBC
- **作用**: 返回用户在特定表上的权限，如SELECT、INSERT、UPDATE等
- API：SQLTablePrivileges
- **是否支持**：不支持
- **标准**：ODBC
- **作用**：返回用户在特定表上的权限，如SELECT、INSERT、UPDATE等
- API: SQLTables
- **是否支持**: 支持
- **标准**: X/Open
- **作用**: 返回存储在数据源的当前数据库中的表信息
- API：SQLTables
- **是否支持**：支持
- **标准**：X/Open
- **作用**：返回存储在数据源的当前数据库中的表信息
- API: SQLProcedures
- **是否支持**: 不支持
- **标准**: ODBC
- **作用**: 返回数据库中可用的存储过程信息，包括名称和类型
- API：SQLProcedures
- **是否支持**：不支持
- **标准**：ODBC
- **作用**：返回数据库中可用的存储过程信息，包括名称和类型
- API: SQLProcedureColumns
- **是否支持**: 不支持
- **标准**: ODBC
- **作用**: 返回存储过程的列信息，包括输入输出参数的详细信息
- API：SQLProcedureColumns
- **是否支持**：不支持
- **标准**：ODBC
- **作用**：返回存储过程的列信息，包括输入输出参数的详细信息
#### 执行事务
- API: SQLTransact
- **是否支持**: 不支持
- **标准**: 弃用
- **作用**: 在 ODBC 3.x 中，ODBC 2.x 函数 SQLTransact 已替换为 SQLEndTran
- API：SQLTransact
- **是否支持**：不支持
- **标准**：弃用
- **作用**：在 ODBC 3.x 中，ODBC 2.x 函数 SQLTransact 已替换为 SQLEndTran
- API: SQLEndTran
- **是否支持**: 支持
- **标准**: ISO 92
- **作用**: 用于提交或回滚事务。TDengine 是非事务性的，因此 SQLEndTran 函数最多只能模拟提交或回滚操作。如果有任何未完成的连接或语句，无论是提交（commit）还是回滚（rollback）都不会成功
- API：SQLEndTran
- **是否支持**：支持
- **标准**：ISO 92
- **作用**：用于提交或回滚事务。TDengine 是非事务性的，因此 SQLEndTran 函数最多只能模拟提交或回滚操作。如果有任何未完成的连接或语句，无论是提交（commit）还是回滚（rollback）都不会成功
#### 终止连接
- API: SQLDisconnect
- **是否支持**: 支持
- **标准**: ISO 92
- **作用**: 断开数据库连接
- API：SQLDisconnect
- **是否支持**：支持
- **标准**：ISO 92
- **作用**：断开数据库连接
- API: SQLFreeHandle
- **是否支持**: 支持
- **标准**: ISO 92
- **作用**: 释放与特定环境、连接、语句或描述符句柄关联的资源
- API：SQLFreeHandle
- **是否支持**：支持
- **标准**：ISO 92
- **作用**：释放与特定环境、连接、语句或描述符句柄关联的资源
- API: SQLFreeConnect
- **是否支持**: 不支持
- **标准**: 弃用
- **作用**: 在 ODBC 3.x 中，ODBC 2.0 函数 SQLFreeConnect 已替换为 SQLFreeHandle
- API：SQLFreeConnect
- **是否支持**：不支持
- **标准**：弃用
- **作用**：在 ODBC 3.x 中，ODBC 2.0 函数 SQLFreeConnect 已替换为 SQLFreeHandle
- API: SQLFreeEnv
- **是否支持**: 不支持
- **标准**: 弃用
- **作用**: 在 ODBC 3.x 中，ODBC 2.0 函数 SQLFreeEnv 已替换为 SQLFreeHandle
- API：SQLFreeEnv
- **是否支持**：不支持
- **标准**：弃用
- **作用**：在 ODBC 3.x 中，ODBC 2.0 函数 SQLFreeEnv 已替换为 SQLFreeHandle
- API: SQLFreeStmt
- **是否支持**: 支持
- **标准**: ODBC
- **作用**: 结束语句处理，丢弃挂起的结果，并且可以选择释放与语句句柄关联的所有资源
- API：SQLFreeStmt
- **是否支持**：支持
- **标准**：ODBC
- **作用**：结束语句处理，丢弃挂起的结果，并且可以选择释放与语句句柄关联的所有资源
- API: SQLCloseCursor
- **是否支持**: 支持
- **标准**: ODBC
- **作用**: 关闭与当前语句句柄关联的游标，并释放游标所使用的所有资源
- API：SQLCloseCursor
- **是否支持**：支持
- **标准**：ODBC
- **作用**：关闭与当前语句句柄关联的游标，并释放游标所使用的所有资源

12
docs/zh/14-reference/05-connector/60-rest-api.mdx
View File

@ -75,12 +75,12 @@ http://<fqdn>:<port>/rest/sql/[db_name][?tz=timezone[&req_id=req_id][&row_with_m
参数说明：
- fqdn: 集群中的任一台主机 FQDN 或 IP 地址。
- port: 配置文件中 httpPort 配置项，缺省为 6041。
- db_name: 可选参数，指定本次所执行的 SQL 语句的默认数据库库名。
- tz: 可选参数，指定返回时间的时区，遵照 IANA Time Zone 规则，如 `America/New_York`。
- req_id: 可选参数，指定请求 id，可以用于 tracing。
- row_with_meta: 可选参数，指定是否每行数据都携带列名，缺省为 false。（3.3.2.0 版本开始支持）
- fqdn：集群中的任一台主机 FQDN 或 IP 地址。
- port：配置文件中 httpPort 配置项，缺省为 6041。
- db_name：可选参数，指定本次所执行的 SQL 语句的默认数据库库名。
- tz：可选参数，指定返回时间的时区，遵照 IANA Time Zone 规则，如 `America/New_York`。
- req_id：可选参数，指定请求 id，可以用于 tracing。
- row_with_meta：可选参数，指定是否每行数据都携带列名，缺省为 false。（3.3.2.0 版本开始支持）
例如：`http://h1.taos.com:6041/rest/sql/test` 是指向地址为 `h1.taos.com:6041` 的 URL，并将默认使用的数据库库名设置为 `test`。

14
docs/zh/14-reference/09-error-code.md
View File

@ -431,7 +431,7 @@ description: TDengine 服务端的错误码列表和详细说明
| 0x80002635 | Incorrect TIMESTAMP value | 主键时间戳列值非法 | 检查并修正 SQL 语句 |
| 0x80002637 | soffset/offset can not be less than 0 | soffset/offset 值非法 | 检查并修正 SQL 语句 |
| 0x80002638 | slimit/soffset only available for PARTITION/GROUP BY query | slimit/soffset 只支持 PARTITION BY/GROUP BY 语句 | 检查并修正 SQL 语句 |
| 0x80002639 | Invalid topic query | 不支持的TOPIC查询语 |
| 0x80002639 | Invalid topic query | 不支持的 TOPIC 查询语法 |
| 0x8000263A | Cannot drop super table in batch | 不支持批量删除超级表 | 检查并修正 SQL 语句 |
| 0x8000263B | Start(end) time of query range required or time range too large | 窗口个数超出限制 | 检查并修正 SQL 语句 |
| 0x8000263C | Duplicated column names | 列名称重复 | 检查并修正 SQL 语句 |
@ -496,21 +496,21 @@ description: TDengine 服务端的错误码列表和详细说明
| 0x80002802 | Invalid function para type | 函数输入参数类型不正确。函数输入参数要求为数值类型，但是用户所给参数为字符串。比如 SUM("abc")。 | 调整函数参数输入为正确类型 |
| 0x80002803 | Invalid function para value | 函数输入参数取值不正确。函数输入参数范围不正确。比如 SAMPLE 函数第二个参数指定采样个数范围为 [1, 1000], 如果不在这个范围内会会报错。 | 调整函数参数输入为正确取值。 |
| 0x80002804 | Not builtin function | 函数非内置函数。内置函数不在的哈希表中会报错，用户应该很少遇见这个问题，否则是内部内置函数哈希初始化的时候出错或者写坏。 | 客户应该不会遇到，如果遇到，说明程序有 bug，咨询开发人员。 |
| 0x80002805 | Duplicate timestamps not allowed in function | 函数输入主键列有重复时间戳。对某些依赖时间线顺序函数做超级表查询时，所有子表数据会按照时间戳进行排序后合并为一条时间线进行计算，因此子表合并后的时间戳可能会出现重复，导致某些计算没有意义而报错。涉及到的函数有：CSUM，DERIVATIVE，DIFF，IRATE，MAVG，STATECOUNT，STATEDURATION，TWA | 如果需要对超级表查询并且使用这些依赖时间线顺序函数时，确保子表中不存在重复时间戳数据。 |
| 0x80002805 | Duplicate timestamps not allowed in function | 函数输入主键列有重复时间戳。对某些依赖时间线顺序函数做超级表查询时，所有子表数据会按照时间戳进行排序后合并为一条时间线进行计算，因此子表合并后的时间戳可能会出现重复，导致某些计算没有意义而报错。涉及到的函数有：CSUM、DERIVATIVE、DIFF、IRATE、MAVG、STATECOUNT、STATEDURATION、TWA | 如果需要对超级表查询并且使用这些依赖时间线顺序函数时，确保子表中不存在重复时间戳数据。 |
## udf
| 错误码 | 错误描述 | 可能的出错场景或者可能的原因 | 建议用户采取的措施 |
| ---------- | ---------------------------------- | ------------------------------------------------------------------------------------- | --------------------------------------------- |
| 0x80002901 | udf is stopping | dnode 退出时，收到 udf 调用 | 停止执行 udf 查询 |
| 0x80002902 | udf pipe read error | taosd读取udfd pipe，发生错误 | udfd异常退出，1）c udf崩溃 2）udfd崩溃 |
| 0x80002903 | udf pipe connect error | taosd建立到udfd的管道连接时，发生错误 | 1)taosd对应的udfd未启动。重启taosd |
| 0x80002904 | udf pip not exist | udf建立，调用，拆除三个阶段，两个阶段中间发生连接错误，导致连接消失，后续阶段继续执行 | udfd异常退出，1）c udf崩溃 2）udfd崩溃 |
| 0x80002905 | udf load failure | udfd加载udf时错误 | 1）mnode中udf不存在 2）udf 加载出错。查看日志 |
| 0x80002902 | udf pipe read error | taosd 读取 udfd pipe，发生错误 | udfd 异常退出，1. c udf 崩溃 2. udfd 崩溃 |
| 0x80002903 | udf pipe connect error | taosd 建立到 udfd 的管道连接时，发生错误 | 1. taosd 对应的 udfd 未启动。重启 taosd |
| 0x80002904 | udf pip not exist | udf 建立，调用，拆除三个阶段，两个阶段中间发生连接错误，导致连接消失，后续阶段继续执行 | udfd 异常退出，1. c udf 崩溃 2. udfd 崩溃 |
| 0x80002905 | udf load failure | udfd 加载 udf 时错误 | 1.mnode 中 udf 不存在 2. udf 加载出错。查看日志 |
| 0x80002906 | udf invalid function input | udf 检查输入 | udf 函数不接受输入，如输入列类型错误 |
| 0x80002907 | udf invalid bufsize | udf 聚合函数中间结果大于创建udf中指定的 bufsize | 增大 bufSize，或者降低中间结果大小 |
| 0x80002908 | udf invalid output type | udf 输出的类型和创建 udf 中指定的类型 | 修改 udf，或者创建 udf 的类型，使得结果相同 |
| 0x80002909 | udf program language not supported | udf编程语言不支持 | 使用支持的语言,当前支持c，python |
| 0x80002909 | udf program language not supported | udf 编程语言不支持 | 使用支持的语言,当前支持 c、python |
| 0x8000290A | udf function execution failure | udf 函数执行错误，如返回错误的行数 | 具体查看错误日志 |

10
docs/zh/25-application/01-car.md
View File

@ -19,9 +19,7 @@ toc_max_heading_level: 4
在面对亿万级别的点位信息时，任何微小的数据处理逻辑错误或冗余都可能导致性能瓶颈。得益于全球社区爱好者的共同努力、超过 53 万个的装机实例部署，以及在极端条件下的严格验证，TDengine 在功能和性能方面均达到顶尖水平。在车联网领域，TDengine 的核心价值体现在以下几个方面。
- 便于采集：作为物联网的一个分支，车联网的技术特点与之一致。TDengine配备了可视化采集界面，用户无须编写代码即可轻松将Kafka、MQTT等通用消息中间件中
的数据导入数据库。此外，提供的可视化性能指标看板大大简化了数据接入和管理
的工作流程。
- 便于采集：作为物联网的一个分支，车联网的技术特点与之一致。TDengine 配备了可视化采集界面，用户无须编写代码即可轻松将 Kafka、MQTT 等通用消息中间件中的数据导入数据库。此外，提供的可视化性能指标看板大大简化了数据接入和管理的工作流程。
- 数据存储：车联网数据具有高度的相关性，例如特定车型的配置信息或同一车辆上不同点位的状态数据。TDengine 的设计理念完美契合车联网的需求，采用“一车一表”的模式，简化了数据存储管理的复杂性。结合云原生架构、冷热数据分离、列式存储以及动态扩容（包括横向、纵向扩容和动态添加存储空间）等技术，TDengine 在数据存储的性能和成本控制方面表现出色。
- 查询分析：TDengine 作为一个开放且简洁的时序大数据平台，提供了丰富的 API，兼容各种分析工具、编程语言和 BI 系统，如 Matlab、R、永洪 BI 等。TDengine 主要采用 SQL，易于学习和使用，支持状态、计数、时间、事件及会话窗口等多种分析模式，并内置了 70 多个基础算子，足以应对日常的分析需求。对于更专业的算法分析，用户可通过 C 或 Python 语言开发 UDF，并将其集成到 TDengine 中。
@ -57,8 +55,4 @@ TDengine能够无缝地从外部消息队列（如MQTT、Kafka）中采集并过
方案特点如下。
- 高性能：该项目服务于一万辆车，数据量呈现快速增长态势，日均写入记录高达约 10 亿条。项目对聚合查询的高效性和存储压缩性能进行了严格的验证，无损压缩率可达 4%。这证明了 TDengine 在处理大规模数据时的卓越性能。
- 乱序治理：尽管消息队列的使用难以避免乱序问题的出现，尤其是在离线数据补传的场景中，乱序数据往往表现为时间戳早于当前车辆存储记录的时间戳。这种乱序写入会导致大量存储碎片的产生，严重时会影响数据库的性能。TDengine 巧妙地解决了这一行业难题，支持在线整理乱序写入，确保数据库性能不受影响。同时，对于异常数据段的删除，也可以通过在线整理实现真正的数据存储空间释放，而不仅仅是索引屏蔽。
- 数据应用：鉴于车辆运营涉及食品安全的特殊性，实时监控当前车辆位置信息显
得尤为重要。TDengine 具备缓存实时数据的功能，无论数据库中已存储多少数据，
仍能保持稳定的性能，毫秒级响应最新数据请求，充分发挥时序数据库的实时特
性。业务中还需要进行历史轨迹回放、行驶里程分析、时间分段分析等多项操作，
TDengine 的强大性能和多功能性为业务分析提供了无限可能。
- 数据应用：鉴于车辆运营涉及食品安全的特殊性，实时监控当前车辆位置信息显得尤为重要。TDengine 具备缓存实时数据的功能，无论数据库中已存储多少数据，仍能保持稳定的性能，毫秒级响应最新数据请求，充分发挥时序数据库的实时特性。业务中还需要进行历史轨迹回放、行驶里程分析、时间分段分析等多项操作，TDengine 的强大性能和多功能性为业务分析提供了无限可能。

9
docs/zh/25-application/02-new-energy.md
View File

@ -18,10 +18,8 @@ toc_max_heading_level: 4
储能系统的核心组件是电芯，对其实时工作参数（如电流、电压、温度、内阻）的监控对于保障储能系统的安全和可靠运行至关重要。如何有效地存储和分析这些海量的测点和数据，已成为储能领域不得不正视的技术难题。这些难题主要体现在如下几个方面。
- 测点量大：分布式光伏组件众多，大型储能系统中电芯数量庞大，需要监测的测点数从数十万到数千万不等。加之较高的采集频率，每天产生的海量监测数据需要进行长期持久化存储。
- 数据接入难：电网调度中心须实时监控分布式光伏电站和储能系统的运行状况，但由于分布式光伏电站目前主要通过配网侧接入电网，数据接入过程面临挑战。
另外，由于营销系统与调度中心的信息化水平存在差异，数据接入过程中存在客观难题：数据提取规则复杂，测点数量庞大，传统的数据采集方案资源消耗大。
- 数据分发难：分布式光伏电站的运行数据一旦接入省级调度中心，就需要迅速分发至各地市的生产区以驱动后续业务。如何实现快速且高效的数据分发，是客户
需要解决的一个棘手问题。
- 数据接入难：电网调度中心须实时监控分布式光伏电站和储能系统的运行状况，但由于分布式光伏电站目前主要通过配网侧接入电网，数据接入过程面临挑战。另外，由于营销系统与调度中心的信息化水平存在差异，数据接入过程中存在客观难题：数据提取规则复杂，测点数量庞大，传统的数据采集方案资源消耗大。
- 数据分发难：分布式光伏电站的运行数据一旦接入省级调度中心，就需要迅速分发至各地市的生产区以驱动后续业务。如何实现快速且高效的数据分发，是客户需要解决的一个棘手问题。
- 聚合分析难：分布式光伏电站的运行数据须根据电站在电网拓扑中的具体隶属关系（如电站隶属于某台配电变压器、馈线、主网变压器）进行多维度的聚合分析。现有技术方案在提供高效聚合分析手段方面存在不足，如性能低下、耗时过长等问题尤为突出。
## TDengine在新能源中的核心价值
@ -31,8 +29,7 @@ toc_max_heading_level: 4
- 支持海量测点：TDengine 能够支持高达 10 亿个时间线，充分满足分布式光伏电站和储能系统的数据处理需求。
- 高性能：面对千万级测点的分钟级数据采集场景，调度业务对时序数据库的写入性能和低延迟有着严苛的要求。TDengine 凭借“一个数据采集点一张表”的创新设计理念，实现了卓越的写入性能，完全契合业务需求。
- 最新状态数据快速查询：在千万级测点数据写入后，调度业务需要时序数据库能够迅速查询各设备的最新状态数据，以驱动后续业务逻辑。TDengine 通过超级表和内置的高速读缓存设计，使用户能够高效查询光伏设备和储能电芯的最新运行数据，使运维人员能够实时获取并监控设备状态，从而提高运维效率。
- 数据订阅与分发：针对需要实时数据分发的业务场景，TDengine内置的消息队列功能从机制上解决了大量数据即时分发的难题，简化了整个系统架构的复
杂性。
- 数据订阅与分发：针对需要实时数据分发的业务场景，TDengine 内置的消息队列功能从机制上解决了大量数据即时分发的难题，简化了整个系统架构的复杂性。
- 开放的生态：TDengine 易于与其他系统集成，兼容多种大数据框架，支持数据的整合与分析，为开发者提供了一个灵活的生态平台。
## TDengine 在新能源中的应用

2
docs/zh/25-application/03-oil.md
View File

@ -28,7 +28,7 @@ toc_max_heading_level: 4
## TDengine在智慧油田中的应用
在一项致力于提升大型油田生产管理水平的技术方案中，客户设定了实现多个关键领域技术集成的目标。这些领域包括但不限于如下这些
在一项致力于提升大型油田生产管理水平的技术方案中，客户设定了实现多个关键领域技术集成的目标。这些领域包括但不限于如下这些。
- 自动化采集与控制：在生产现场构建先进的自动化系统，以实现数据的实时采集和精确控制，提升生产过程的自动化水平。
- 生产视频系统：整合高效的视频监控系统，对生产过程进行全面监控，确保作业安全，并为管理层提供实时、直观的决策支持。
- 工业物联网：运用物联网技术，将各种传感器和设备无缝连接，实现数据的远程采集与分析，提高油田运营的透明度和智能化程度。

9
docs/zh/25-application/04-manufacture.md
View File

@ -15,11 +15,9 @@ toc_max_heading_level: 4
![IEC 62264-1 5 层架构模型](./manufacture-1.png)
随着工业数字化的巨浪席卷而来，我们见证了数据采集量的爆炸式增长和分析需求的日益复杂化，随之而来的问题和挑战也愈发凸显。
- 海量设备数据采集：在过去的十余年里，制造业的数字化进程取得了显著进展。工厂的数据采集点从传统的数千个激增至数十万甚至数百万个。面对如此庞大的
数据采集需求，传统的实时数据库已显得力不从心。
- 海量设备数据采集：在过去的十余年里，制造业的数字化进程取得了显著进展。工厂的数据采集点从传统的数千个激增至数十万甚至数百万个。面对如此庞大的数据采集需求，传统的实时数据库已显得力不从心。
- 动态扩容：随着数据的逐步接入，初期的硬件配置往往较为有限。随着业务量的增加和数据量的上升，硬件资源必须迅速扩展以满足业务的正常运行。然而，一旦系统上线运行，通常不允许进行停机扩容，这就要求系统在设计时就要考虑到未来的扩展性。
- 数据关联与多维分析：传统工业实时数据库通常只包含几个固定的字段，如变量名、变量值、质量戳和时间戳，缺乏信息间的关联性，这使得复杂的多维分析变
得难以执行。
- 数据关联与多维分析：传统工业实时数据库通常只包含几个固定的字段，如变量名、变量值、质量戳和时间戳，缺乏信息间的关联性，这使得复杂的多维分析变得难以执行。
- 截面查询与插值查询：为了满足报表和其他统计需求，系统需要支持历史截面查询以及按指定时间间隔进行的线性插值查询。
- 第三方系统数据库对接：除了设备数据以外，还须采集来自各个生产系统的数据，这些系统通常位于过程监控层或生产管理层。这就要求系统能够实时采集数据、迁移历史数据，并在网络断开时能够断线续传。除了 API 以外，常见的对接方式还包括数据库对接，例如，与LIMIS对接，采集其关系型数据库中存储的时序数据，或与第三方生产数据库（如AVEVA PI System或Wonderware系统）对接，获取实时、历史和报警数据。
- 与SCADA（Supervisory Control and Data Acquisition，监控控制与数据采集）系统对接：SCADA 系统作为过程监控层的核心，汇集了站内和厂区的所有生产数据，并提供了直观易用的开发、运行和管理界面。然而，其自带的传统实时数据库在分析能力和高密度点位容量上存在限制，通常仅支持约 1 万个点位。因此，将 SCADA 系统与性能更优越的数据库相结合，充分发挥双方的优势，通过面向操作技术层的模块化组态开发，为工业控制系统注入新的活力，已成为工业数字化发展的重要方向。
@ -58,7 +56,6 @@ toc_max_heading_level: 4
- 统计意义的降采样同步：TDengine 利用流计算技术，实现了具有统计意义的降采样数据同步。通过这种方式，可以在不损失数据精度的前提下，对数据进行降采样处理，确保即使在数据时间颗粒度增大的情况下，也能保持数据的准确性。流计算的使用方式简便，无须复杂配置，客户只须根据自己的需求编写SQL即可实现。
- 订阅式传输：TDengine 采用了类似 Kafka 的消息订阅方式进行数据同步，相较于传统的周期性同步和普通订阅访问，这种方式实现了负载隔离和流量削峰，提高了同步的稳定性和效率。消息订阅机制遵循至少一次消费原则，确保在网络断线故障恢复后，能够从断点处继续消费数据，或者从头开始消费，以保证消费者能够接收到完整的生产数据。
- 操作行为同步：TDengine 能够将操作行为同步到中心端，确保设备故障或人为对边缘侧数据的修改和删除操作能够实时反映到中心侧，维护了数据的一致性。
- 数据传输压缩：在数据传输过程中，TDengine实现了高达20%的数据压缩率，结合流计算的降采样同步，显著降低了同步过程对带宽的占用，提高了数据传输
效率。
- 数据传输压缩：在数据传输过程中，TDengine 实现了高达 20% 的数据压缩率，结合流计算的降采样同步，显著降低了同步过程对带宽的占用，提高了数据传输效率。
- 多种同步方式：TDengine 支持多对一、一对多以及多对多的数据同步模式，满足不同场景下的数据同步需求。
- 支持双活：数据中心侧可实现异地灾备。边缘侧的 TDengine 或第三方客户端能够根据集团中心侧的 TDengine 状态进行智能连接。若主 TDengine 集群发生故障，无法对外提供服务，异地备用的 TDengine 集群将立即激活，接管所有客户端的访问连接，包括写入和查询功能。一旦主 TDengine 集群恢复正常，备用集群会将历史缓存和实时数据同步回主集群，整个过程对客户端透明，无须人工干预。

3
docs/zh/25-application/05-finance.md
View File

@ -16,8 +16,7 @@ toc_max_heading_level: 4
在时序数据处理领域，金融机构面临着一系列核心需求与挑战，这些需求与挑战不仅关系到日常运营的效率，还直接影响到决策的准确性和业务的创新能力。
- 高性能写入：金融机构需要的是一个能够实时处理巨量数据流的平台。随着交易活动的频繁和市场数据的不断更新，平台必须能够每秒处理数以亿计的数据点，
确保数据的即时性和完整性，以支持实时的交易决策和风险管理。
- 高性能写入：金融机构需要的是一个能够实时处理巨量数据流的平台。随着交易活动的频繁和市场数据的不断更新，平台必须能够每秒处理数以亿计的数据点，确保数据的即时性和完整性，以支持实时的交易决策和风险管理。
- 强大的读取及数据消费性能：金融市场的特点是业务场景多变，这要求平台必须具备高度的数据读取和计算能力。例如，量化投资策略的研发依赖于实时行情数据和衍生数据的深度分析。平台需要支持高效的数据查询和计算，以便量化分析师能够快速回测模型、优化策略，并进行实时学习和调整。
- 计算性能：资产和衍生品的监控对平台的计算性能提出了更高的要求。金融机构需要能够执行复杂的统计分析、风险预测和价格发现等计算任务，以监控市场动态和评估投资组合的风险。这要求平台不仅要有强大的计算能力，还要能够提供快速响应，以支持实时决策和快速反应市场变化。

24
docs/zh/26-tdinternal/01-arch.md
View File

@ -40,7 +40,7 @@ dnode 在 TDengine 集群中的唯一标识由其实例的 endpoint（EP）决
在集群内部，一个 vnode 由其所归属的 dnode 的 endpoint 和所属的 vgroup ID 唯一标识。管理节点负责创建和管理这些 vnode，确保它们能够正常运行并协同工作。
**管理节点（mnode）：**
mnode（管理节点）是 TDengine 集群中的核心逻辑单元，负责监控和维护所有 dnode的运行状态，并在节点之间实现负载均衡（如图 15-1 中的 M1、M2、M3 所示）。作为元数据（包括用户、数据库、超级表等）的存储和管理中心，mnode 也被称为 MetaNode。
mnode（管理节点）是 TDengine 集群中的核心逻辑单元，负责监控和维护所有 dnode的运行状态，并在节点之间实现负载均衡（如图 1 中的 M1、M2、M3 所示）。作为元数据（包括用户、数据库、超级表等）的存储和管理中心，mnode 也被称为 MetaNode。
为了提高集群的高可用性和可靠性，TDengine 集群允许有多个（最多不超过 3 个）mnode。这些 mnode 自动组成一个虚拟的 mnode 组，共同承担管理职责。mnode 支持多副本，并采用 Raft 一致性协议来确保数据的一致性和操作的可靠性。在 mnode 集群中，任何数据更新操作都必须在 leader 节点上执行。
@ -49,7 +49,7 @@ mnode 集群的第 1 个节点在集群部署时自动创建，而其他节点
为了实现集群内部的信息共享和通信，每个 dnode 通过内部消息交互机制自动获取整个集群中所有 mnode 所在的 dnode 的 endpoint。
**计算节点（qnode）：**
qnode（计算节点）是 TDengine 集群中负责执行查询计算任务的虚拟逻辑单元，同时也处理基于系统表的 show 命令。为了提高查询性能和并行处理能力，集群中可以配置多个 qnode，这些 qnode 在整个集群范围内共享使用（如图 15-1 中的 Q1、Q2、Q3 所示）。
qnode（计算节点）是 TDengine 集群中负责执行查询计算任务的虚拟逻辑单元，同时也处理基于系统表的 show 命令。为了提高查询性能和并行处理能力，集群中可以配置多个 qnode，这些 qnode 在整个集群范围内共享使用（如图 1 中的 Q1、Q2、Q3 所示）。
与 dnode 不同，qnode 并不与特定的数据库绑定，这意味着一个 qnode 可以同时处理来自多个数据库的查询任务。每个 dnode 上最多有一个 qnode，并由其所归属的 dnode 的endpoint 唯一标识。
@ -155,14 +155,14 @@ TDengine 集群可以容纳单个、多个甚至几千个数据节点。应用
<center> 图 2 TDengine 典型的操作流程 </center>
1. 应用通过 JDBC 或其他 API 接口发起插入数据的请求。
2. taosc 会检查缓存，看是否保存有该表所在数据库的 vgroup-info 信息。如果有，直接到第 4 步。如果没有，taosc 将向 mnode 发出 get vgroup-info 请求。
3. mnode 将该表所在数据库的 vgroup-info 返回给 taosc。Vgroup-info 包含数据库的 vgroup 分布信息（vnode ID 以及所在的 dnode 的 End Point，如果副本数为 N，就有 N 组 End Point），还包含每个 vgroup 中存储数据表的 hash 范围。如果 taosc 迟迟得不到 mnode 回应，而且存在多个 mnode，taosc 将向下一个 mnode 发出请求。
4. taosc 会继续检查缓存，看是否保存有该表的 meta-data。如果有，直接到第 6 步。如果没有，taosc 将向 vnode 发出 get meta-data 请求。
5. vnode 将该表的 meta-data 返回给 taosc。Meta-data 包含有该表的 schema。
6. taosc 向 leader vnode 发起插入请求。
7. vnode 插入数据后，给 taosc 一个应答，表示插入成功。如果 taosc 迟迟得不到 vnode 的回应，taosc 会认为该节点已经离线。这种情况下，如果被插入的数据库有多个副本，taosc 将向 vgroup 里下一个 vnode 发出插入请求。
8. taosc 通知 APP，写入成功。
- 第 1 步：应用通过 JDBC 或其他 API 接口发起插入数据的请求。
- 第 2 步：taosc 会检查缓存，看是否保存有该表所在数据库的 vgroup-info 信息。如果有，直接到第 4 步。如果没有，taosc 将向 mnode 发出 get vgroup-info 请求。
- 第 4 步：mnode 将该表所在数据库的 vgroup-info 返回给 taosc。Vgroup-info 包含数据库的 vgroup 分布信息（vnode ID 以及所在的 dnode 的 End Point，如果副本数为 N，就有 N 组 End Point），还包含每个 vgroup 中存储数据表的 hash 范围。如果 taosc 迟迟得不到 mnode 回应，而且存在多个 mnode，taosc 将向下一个 mnode 发出请求。
- 第 4 步：taosc 会继续检查缓存，看是否保存有该表的 meta-data。如果有，直接到第 6 步。如果没有，taosc 将向 vnode 发出 get meta-data 请求。
- 第 5 步：vnode 将该表的 meta-data 返回给 taosc。Meta-data 包含有该表的 schema。
- 第 6 步：taosc 向 leader vnode 发起插入请求。
- 第 7 步：vnode 插入数据后，给 taosc 一个应答，表示插入成功。如果 taosc 迟迟得不到 vnode 的回应，taosc 会认为该节点已经离线。这种情况下，如果被插入的数据库有多个副本，taosc 将向 vgroup 里下一个 vnode 发出插入请求。
- 第 8 步：taosc 通知 APP，写入成功。
对于第二步，taosc 启动时，并不知道 mnode 的 End Point，因此会直接向配置的集群对外服务的 End Point 发起请求。如果接收到该请求的 dnode 并没有配置 mnode，该 dnode 会在回复的消息中告知 mnode EP 列表，这样 taosc 会重新向新的 mnode 的 EP 发出获取 meta-data 的请求。
@ -315,7 +315,7 @@ TDengine 采用了一种数据驱动的策略来实现缓存数据的持久化
每个数据文件块（以 .data 结尾）都配有一个索引文件（以 .head 结尾），该索引文件包含每张表的各个数据文件块的摘要信息，记录了每个数据文件块在数据文件中的偏移量、数据的起始时间和结束时间等信息，以便于快速定位所需数据。此外，每个数据文件块还有一个与之关联的 last 文件（以 .last 结尾），该文件旨在防止数据文件块在落盘时发生碎片化。如果某张表落盘的记录条数未达到数据库参数 minRows（每块最小记录条数）的要求，这些记录将首先存储在 last 文件中，待下次落盘时，新落盘的记录将与 last文件中的记录合并，然后再写入数据文件块。
在数据写入硬盘的过程中，是否对数据进行压缩取决于数据库参数 comp 的设置。TDengine 提供了 3 种压缩选项—无压缩、一级压缩和二级压缩，对应的 comp 值分别为 0、1 和 2。一级压缩会根据数据类型采用相应的压缩算法，如 delta-delta 编码、simple8B 方法、zig-zag 编码、LZ4 等。二级压缩则在一级压缩的基础上进一步使用通用压缩算法，以实现更高的压缩率。
在数据写入硬盘的过程中，是否对数据进行压缩取决于数据库参数 comp 的设置。TDengine 提供了 3 种压缩选项—无压缩、一级压缩和二级压缩，对应的 comp 值分别为 0、1 和 2。一级压缩会根据数据类型采用相应的压缩算法，如 delta-delta 编码、simple8B 编码、zig-zag 编码、LZ4 等。二级压缩则在一级压缩的基础上进一步使用通用压缩算法，以实现更高的压缩率。
### 预计算
@ -325,7 +325,7 @@ TDengine 采用了一种数据驱动的策略来实现缓存数据的持久化
### 多级存储与对象存储
说明：多级存储功能仅企业版支持，从 2.0.16.0 版本开始提供。
说明：多级存储功能仅企业版支持。
在默认配置下，TDengine 会将所有数据保存在 /var/lib/taos 目录下，而且每个 vnode 的数据文件保存在该目录下的不同目录。为扩大存储空间，尽量减少文件读取的瓶颈，提高数据吞吐率 TDengine 可通过配置系统参数 dataDir 让多个挂载的硬盘被系统同时使用。

18
docs/zh/26-tdinternal/05-query.md
View File

@ -87,14 +87,14 @@ TDengine 为了解决实际应用中对不同数据采集点数据进行高效
![多表聚合查询流程](./aggquery.png)
具体步骤说明如下。
第 1 步，taosc 从 mnode 获取库和表的元数据信息。
第 2 步，mnode 返回请求的元数据信息。
第 3 步，taosc 向超级表所属的每个 vnode 发送查询请求。
第 4 步，vnode 启动本地查询，在获得查询结果后返回查询响应。
第 5 步，taosc 向聚合节点（在本例中为 qnode）发送查询请求。
第 6 步，qnode 向每个 vnode 节点发送数据请求消息来拉取数据。
第 7 步，vnode 返回本节点的查询计算结果。
第 8 步，qnode 完成多节点数据聚合后将最终查询结果返回给客户端。
- 第 1 步，taosc 从 mnode 获取库和表的元数据信息。
- 第 2 步，mnode 返回请求的元数据信息。
- 第 3 步，taosc 向超级表所属的每个 vnode 发送查询请求。
- 第 4 步，vnode 启动本地查询，在获得查询结果后返回查询响应。
- 第 5 步，taosc 向聚合节点（在本例中为 qnode）发送查询请求。
- 第 6 步，qnode 向每个 vnode 节点发送数据请求消息来拉取数据。
- 第 7 步，vnode 返回本节点的查询计算结果。
- 第 8 步，qnode 完成多节点数据聚合后将最终查询结果返回给客户端。
TDengine 为了提升聚合计算速度，在 vnode 内实现了标签数据与时序数据的分离存储。首先，系统会在内存中过滤标签数据，以确定需要参与聚合操作的表的集合。这样做可以显著减少需要扫描的数据集，从而大幅提高聚合计算的速度。
@ -127,6 +127,6 @@ TDengine 针对不同类型的缓存对象采用了相应的缓存管理策略
![缓存方案](./cache.png)
- 元数据缓存（meta data）：包括数据库、超级表、用户、节点、视图、虚拟节点等信息，以及表的 schema 和其所在虚拟节点的映射关系。通过在 taosc 缓存元数据可以避免频繁地向 mnode/vnode 请求元数据。taosc 对元数据的缓存采用固定大小的缓存空间，先到先得，直到缓存空间用完。当缓存空间用完时，缓存会被进行部分淘汰处理，用来缓存新进请求所需要的元数据。
- 时序数据缓存（time series data）：时序数据首先被缓存在 vnode 的内存中，以SkipList 形式组织，当达到落盘条件后，将时序数据进行压缩，写入数据存储文件
- 时序数据缓存（time series data）：时序数据首先被缓存在 vnode 的内存中，以 skipList 形式组织，当达到落盘条件后，将时序数据进行压缩，写入数据存储文件
中，并从缓存中清除。
- 最新数据缓存（last/last_row）：对时序数据中的最新数据进行缓存，可以提高最新数据的查询效率。最新数据以子表为单元组织成 KV 形式，其中，K 是子表 ID，V 是该子表中每列的最后一个非 NULL 以及最新的一行数据。

5
docs/zh/26-tdinternal/09-stream.md
View File

@ -13,8 +13,7 @@ TDengine 流计算的架构如下图所示。当用户输入用于创建流的 S
mnode 包含与流计算相关的如下 4 个逻辑模块。
- 任务调度，负责将逻辑执行计划转化为物理执行计划，并下发到每个 vnode。
- meta store，负责存储流计算任务的元数据信息以及流任务相应的 DAG 信息。
- 检查点调度，负责定期生成检查点（checkpoint）事务，并下发到各 source task（源
任务）。
- 检查点调度，负责定期生成检查点（checkpoint）事务，并下发到各 source task（源任务）。
- exec 监控，负责接收上报的心跳、更新 mnode 中各任务的执行状态，以及定期监控检查点执行状态和 DAG 变动信息。
此外，mnode 还承担着向流计算任务下发控制命令的重要角色，这些命令包括但不限于暂停、恢复执行、删除流任务及更新流任务的上下游信息等。
@ -67,7 +66,7 @@ TDengine 的流计算功能允许根据记录的事件时间将数据划分到
![流计算任务组成](./streamtask.png)
按照流任务承担任务的不同，可将其划分为 3 个类别—source task（源任务）、agg task（聚合任务）和 sink task（写回任务）。
按照流任务承担任务的不同，可将其划分为 3 个类别：source task（源任务）、agg task（聚合任务）和 sink task（写回任务）。
### source task

6
docs/zh/26-tdinternal/12-log.md
View File

@ -11,7 +11,7 @@ TDengine 通过日志文件记录系统运行状态，帮助用户监控系统
### 普通日志实现逻辑
- 普通日志分同步和异步两种方式，同步立即写入日志文件，异步写入到 buff 里，然后定时写入日志文件。
- 异步方式日志文件缓存在循环 buff 里， buff 的大小为 buffSize = 20 M。如果某次写buf 的日志大小大于buf 可用空间，本次日志会舍弃，日志里记录: ...Lost N lines here...
- 异步方式日志文件缓存在循环 buff 里， buff 的大小为 buffSize = 20M。如果某次写 buf 的日志大小大于buf 可用空间，本次日志会舍弃，日志里记录： ...Lost N lines here...
![TDengine 日志循环buff](./normal_log1.png)
- 异步线程里每隔 1s 会更新磁盘信息用于判断是否有空间写日志
- 异步线程每隔 Interval 时间处理一次写入逻辑。写入规则如下：
@ -69,13 +69,13 @@ TDengine 通过日志文件记录系统运行状态，帮助用户监控系统
- 因为上报数据和删除文件里的上报内容没法作为一个原子操作，所以如果上报后还没删除数据就 crash，可能导致下次重复上报，重复上报的数据会覆盖，并没丢失，影响很小。
- 另外为了保证性能，slow log thread 线程把慢 sql 日志写入临时文件缓存，只保证刷新到操作系统的磁盘缓冲区，并不真正每次都 fsync 到磁盘，所以如果机器断电，仍可能丢失数据。该异常出现概率很小，可以容忍此种情况下的数据丢失。
### 慢日志行为说明
- 慢日志一方面会记录到本地慢日志文件中，另一方面会通过 taosAdapter 发送到 taosKeeper 进行结构化存储（需打开 monitorr 开关）。
- 慢日志一方面会记录到本地慢日志文件中，另一方面会通过 taosAdapter 发送到 taosKeeper 进行结构化存储（需打开 monitor 开关）。
- 慢日志文件存储规则为：
- 慢日志文件一天一个，如果当天没有慢日志，没有当天的文件。
- 文件名为 taosSlowLog.yyyy-mm-dd（taosSlowLog.2024-08-02），日志存储路径通过 logDir 配置。
- 多个客户端的日志存储在相应日志路径下的同一个 taosSlowLog.yyyy.mm.dd 文件里。
- 慢日志文件不自动删除，不压缩。
- 使用和普通日志文件相同的三个参数 logDir, minimalLogDirGB, asyncLog。另外两个参数 numOfLogLines，logKeepDays 不适用于慢日志。
- 使用和普通日志文件相同的三个参数 logDir、minimalLogDirGB、asyncLog。另外两个参数 numOfLogLines、logKeepDays 不适用于慢日志。
## 日志级别说明

38
docs/zh/27-train-faq/01-faq.md
View File

@ -7,20 +7,20 @@ description: 一些常见问题的解决方法汇总
如果 FAQ 中的信息不能够帮到您，需要 TDengine 技术团队的技术支持与协助，请将以下两个目录中内容打包：
1. /var/log/taos （如果没有修改过默认路径）
2. /etc/taos（如果没有指定其他配置文件路径）
1. `/var/log/taos` （如果没有修改过默认路径）
2. `/etc/taos` （如果没有指定其他配置文件路径）
附上必要的问题描述，包括使用的 TDengine 版本信息、平台环境信息、发生该问题的执行操作、出现问题的表征及大概的时间，在 [GitHub](https://github.com/taosdata/TDengine) 提交 issue。
为了保证有足够的 debug 信息，如果问题能够重复，请修改/etc/taos/taos.cfg 文件，最后面添加一行“debugFlag 135"(不带引号本身），然后重启 taosd, 重复问题，然后再递交。也可以通过如下 SQL 语句，临时设置 taosd 的日志级别。
为了保证有足够的 debug 信息，如果问题能够重复，请修改 `/etc/taos/taos.cfg` 文件，最后面添加一行 `debugFlag 135`，然后重启 taosd, 重复问题，然后再递交。也可以通过如下 SQL 语句，临时设置 taosd 的日志级别。
```
alter dnode <dnode_id> 'debugFlag' '135';
```
其中 dnode_id 请从 show dnodes; 命令输出中获取。
其中 dnode_id 请从 `show dnodes` 命令输出中获取。
但系统正常运行时，请一定将 debugFlag 设置为 131，否则会产生大量的日志信息，降低系统效率。
但系统正常运行时，请一定将 debugFlag 设置为 `131`，否则会产生大量的日志信息，降低系统效率。
## 常见问题列表
@ -56,17 +56,17 @@ description: 一些常见问题的解决方法汇总
3. 在服务器，执行 `systemctl status taosd` 检查 *taosd* 运行状态。如果没有运行，启动 *taosd*
4. 确认客户端连接时指定了正确的服务器 FQDN (Fully Qualified Domain Name —— 可在服务器上执行 Linux/macOS 命令 hostname -f 获得），FQDN 配置参考：[一篇文章说清楚 TDengine 的 FQDN](https://www.taosdata.com/blog/2020/09/11/1824.html)。
4. 确认客户端连接时指定了正确的服务器 FQDN (Fully Qualified Domain Name —— 可在服务器上执行 Linux/macOS 命令 `hostname -f` 获得），FQDN 配置参考 [一篇文章说清楚 TDengine 的 FQDN](https://www.taosdata.com/blog/2020/09/11/1824.html)。
5. ping 服务器 FQDN，如果没有反应，请检查你的网络，DNS 设置，或客户端所在计算机的系统 hosts 文件。如果部署的是 TDengine 集群，客户端需要能 ping 通所有集群节点的 FQDN。
6. 检查防火墙设置（Ubuntu 使用 ufw status，CentOS 使用 firewall-cmd --list-port），确保集群中所有主机在端口 6030/6041 上的 TCP/UDP 协议能够互通。
7. 对于 Linux 上的 JDBC（ODBC, Python, Go 等接口类似）连接, 确保*libtaos.so*在目录*/usr/local/taos/driver*里, 并且*/usr/local/taos/driver*在系统库函数搜索路径*LD_LIBRARY_PATH*里
7. 对于 Linux 上的 JDBC（ODBC、Python、Go 等接口类似）连接，确保 *libtaos.so* 在目录 */usr/local/taos/driver* 里，并且 */usr/local/taos/driver* 在系统库函数搜索路径 *LD_LIBRARY_PATH* 里
8. 对于 macOS 上的 JDBC（ODBC, Python, Go 等接口类似）连接, 确保*libtaos.dylib*在目录*/usr/local/lib*里, 并且*/usr/local/lib*在系统库函数搜索路径*LD_LIBRARY_PATH*里
8. 对于 macOS 上的 JDBC（ODBC、Python、Go 等接口类似）连接，确保 *libtaos.dylib* 在目录 */usr/local/lib* 里，并且 */usr/local/lib* 在系统库函数搜索路径 *LD_LIBRARY_PATH* 里
9. 对于 Windows 上的 JDBC, ODBC, Python, Go 等连接，确保*C:\TDengine\driver\taos.dll*在你的系统库函数搜索目录里 (建议*taos.dll*放在目录 _C:\Windows\System32_)
9. 对于 Windows 上的 JDBC、ODBC、Python、Go 等连接，确保 *C:\TDengine\driver\taos.dll* 在你的系统库函数搜索目录里 (建议 *taos.dll* 放在目录 _C:\Windows\System32_)
10. 如果仍不能排除连接故障
@ -75,7 +75,7 @@ description: 一些常见问题的解决方法汇总
检查服务器侧 TCP 端口连接是否工作：`nc -l {port}`
检查客户端侧 TCP 端口连接是否工作：`nc {hostIP} {port}`
- Windows 系统请使用 PowerShell 命令 Test-NetConnection -ComputerName \{fqdn} -Port \{port} 检测服务段端口是否访问
- Windows 系统请使用 PowerShell 命令 `Test-NetConnection -ComputerName \{fqdn} -Port \{port}` 检测服务段端口是否访问
11. 也可以使用 taos 程序内嵌的网络连通检测功能，来验证服务器和客户端之间指定的端口连接是否通畅：[运维指南](../../operation)。
@ -145,7 +145,7 @@ local_option: {
其含义是，在当前的命令行程序下，清空本机所有客户端生成的日志文件(resetLog)，或修改一个特定模块的日志记录级别（只对当前命令行程序有效，如果 taos 命令行程序重启，则需要重新设置）：
- value 的取值可以是：131（输出错误和警告日志），135（ 输出错误、警告和调试日志），143（ 输出错误、警告、调试和跟踪日志）。
- value 的取值可以是：131（输出错误和警告日志）、135（ 输出错误、警告和调试日志）、143（ 输出错误、警告、调试和跟踪日志）。
### 12. go 语言编写组件编译失败怎样解决？
@ -192,7 +192,7 @@ TDengine 中时间戳的时区总是由客户端进行处理，而与服务端
这个现象可能是因为 taosAdapter 没有被正确启动引起的，需要执行：```systemctl start taosadapter``` 命令来启动 taosAdapter 服务。
需要说明的是，taosAdapter 的日志路径 path 需要单独配置，默认路径是 /var/log/taos ；日志等级 logLevel 有 8 个等级，默认等级是 info ，配置成 panic 可关闭日志输出。请注意操作系统 / 目录的空间大小，可通过命令行参数、环境变量或配置文件来修改配置，默认配置文件是 /etc/taos/taosadapter.toml 。
需要说明的是，taosAdapter 的日志路径 path 需要单独配置，默认路径是 /var/log/taos ；日志等级 logLevel 有 8 个等级，默认等级是 info ，配置成 panic 可关闭日志输出。请注意操作系统 `/` 目录的空间大小，可通过命令行参数、环境变量或配置文件来修改配置，默认配置文件是 /etc/taos/taosadapter.toml 。
有关 taosAdapter 组件的详细介绍请看文档：[taosAdapter](../../reference/components/taosadapter/)
@ -254,19 +254,19 @@ launchctl limit maxfiles
TDengine 中的所有名称，包括数据库名、表名等都是区分大小写的，如果这些名称在程序或 TDengine CLI 中没有使用反引号（`）括起来使用，即使你输入的是大写的，引擎也会转化成小写来使用，如果名称前后加上了反引号，引擎就不会再转化成小写，会保持原样来使用。
### 23 在 TDengine CLI中查询，字段内容不能完全显示出来怎么办？
可以使用 \G 参数来竖式显示，如 show databases\G; （为了输入方便，在"\"后加 TAB 键，会自动补全后面的内容）
可以使用 `\G` 参数来竖式显示，如 `show databases\G;` （为了输入方便，在"\"后加 TAB 键，会自动补全后面的内容）
### 24 使用 taosBenchmark 测试工具写入数据查询很快，为什么我写入的数据查询非常慢？
TDengine 在写入数据时如果有很严重的乱序写入问题，会严重影响查询性能，所以需要在写入前解决乱序的问题。如果业务是从 kafka 消费写入，请合理设计消费者，尽可能的一个子表数据由一个消费者去消费并写入，避免由设计产生的乱序。
TDengine 在写入数据时如果有很严重的乱序写入问题，会严重影响查询性能，所以需要在写入前解决乱序的问题。如果业务是从 Kafka 消费写入，请合理设计消费者，尽可能的一个子表数据由一个消费者去消费并写入，避免由设计产生的乱序。
### 25 我想统计下前后两条写入记录之间的时间差值是多少？
使用 DIFF 函数，可以查看时间列或数值列前后两条记录的差值，非常方便，详细说明见 SQL 手册->函数->DIFF
### 26 遇到报错 “DND ERROR Version not compatible,cliver : 3000700swr wer : 3020300”
说明客户端和服务端版本不兼容，这里cliver的版本是3.0.7.0,server版本是 3.2.3.0。目前的兼容策略是前三位一致，client 和 sever才能兼容。
### 26 遇到报错 “DND ERROR Version not compatible, client: 3000700, server: 3020300”
说明客户端和服务端版本不兼容，这里 client 的版本是 3.0.7.0，server 版本是 3.2.3.0。目前的兼容策略是前三位一致，client 和 sever 才能兼容。
### 27 修改 database 的 root 密码后，启动 taos 遇到报错 “failed to connect to server, reason: Authentication failure”
默认情况，启动taos服务会使用系统默认的用户名（root）和密码尝试连接taosd，在root密码修改后，启用taos连接就需要指明用户名和密码，例如: taos -h xxx.xxx.xxx.xxx -u root -p，然后输入新密码进行连接。
默认情况，启动taos服务会使用系统默认的用户名（root）和密码尝试连接 taosd，在 root 密码修改后，启用 taos 连接就需要指明用户名和密码，例如 `taos -h xxx.xxx.xxx.xxx -u root -p`，然后输入新密码进行连接。
### 28 修改 database 的 root 密码后，Grafana 监控插件 TDinsight 无数据展示
TDinsight 插件中展示的数据是通过 taosKeeper 和 taosAdapter 服务收集并存储于 TD 的 log 库中，在 root 密码修改后，需要同步更新 taosKeeper 和 taosAdapter 配置文件中对应的密码信息，然后重启 taosKeeper 和 taosAdapter 服务（注：若是集群需要重启每个节点上的对应服务）。
@ -277,11 +277,11 @@ TDinsight插件中展示的数据是通过taosKeeper和taosAdapter服务收集
### 30 为什么开源版 TDengine 的主进程会建立一个与公网的连接？
这个连接只会上报不涉及任何用户数据的最基本信息，用于官方了解产品在世界范围内的分布情况，进而优化产品，提升用户体验，具体采集项目为：集群名、操作系统版本、cpu信息等。
该特性为可选配置项，在开源版中默认开启，具体参数为 telemetryReporting , 在官方文档中有做说明，链接如下：[参数简介](https://docs.taosdata.com/reference/components/taosd/#%E7%9B%91%E6%8E%A7%E7%9B%B8%E5%85%B3)
该特性为可选配置项，在开源版中默认开启，具体参数为 telemetryReporting，在官方文档中有做说明，链接如下：[参数简介](https://docs.taosdata.com/reference/components/taosd/#%E7%9B%91%E6%8E%A7%E7%9B%B8%E5%85%B3)
您可以随时关闭该参数，只需要在taos.cfg 中修改 telemetryReporting 为 0，然后重启数据库服务即可。
代码位于:[点击此处](https://github.com/taosdata/TDengine/blob/62e609c558deb764a37d1a01ba84bc35115a85a4/source/dnode/mnode/impl/src/mndTelem.c)
代码位于：[点击此处](https://github.com/taosdata/TDengine/blob/62e609c558deb764a37d1a01ba84bc35115a85a4/source/dnode/mnode/impl/src/mndTelem.c)
此外，对于安全性要求极高的企业版 TDengine Enterprise 来说，此参数不会工作。

51
include/common/tanalytics.h
View File

@ -25,11 +25,12 @@
extern "C" {
#endif
#define ANAL_FORECAST_DEFAULT_ROWS 10
#define ANAL_FORECAST_DEFAULT_CONF 95
#define ANAL_FORECAST_DEFAULT_WNCHECK 1
#define ANAL_FORECAST_MAX_ROWS 40000
#define ANAL_ANOMALY_WINDOW_MAX_ROWS 40000
#define ANALY_FORECAST_DEFAULT_ROWS 10
#define ANALY_FORECAST_DEFAULT_CONF 95
#define ANALY_FORECAST_DEFAULT_WNCHECK 1
#define ANALY_FORECAST_MAX_HISTORY_ROWS 40000
#define ANALY_MAX_FC_ROWS 1024
#define ANALY_ANOMALY_WINDOW_MAX_ROWS 40000
typedef struct {
EAnalAlgoType type;
@ -65,30 +66,30 @@ typedef struct {
int32_t taosAnalyticsInit();
void taosAnalyticsCleanup();
SJson *taosAnalSendReqRetJson(const char *url, EAnalHttpType type, SAnalyticBuf *pBuf);
SJson *taosAnalySendReqRetJson(const char *url, EAnalHttpType type, SAnalyticBuf *pBuf);
int32_t taosAnalGetAlgoUrl(const char *algoName, EAnalAlgoType type, char *url, int32_t urlLen);
bool taosAnalGetOptStr(const char *option, const char *optName, char *optValue, int32_t optMaxLen);
bool taosAnalGetOptInt(const char *option, const char *optName, int64_t *optValue);
int64_t taosAnalGetVersion();
void taosAnalUpdate(int64_t newVer, SHashObj *pHash);
int32_t taosAnalyGetAlgoUrl(const char *algoName, EAnalAlgoType type, char *url, int32_t urlLen);
bool taosAnalyGetOptStr(const char *option, const char *optName, char *optValue, int32_t optMaxLen);
bool taosAnalyGetOptInt(const char *option, const char *optName, int64_t *optValue);
int64_t taosAnalyGetVersion();
void taosAnalyUpdate(int64_t newVer, SHashObj *pHash);
int32_t tsosAnalBufOpen(SAnalyticBuf *pBuf, int32_t numOfCols);
int32_t taosAnalBufWriteOptStr(SAnalyticBuf *pBuf, const char *optName, const char *optVal);
int32_t taosAnalBufWriteOptInt(SAnalyticBuf *pBuf, const char *optName, int64_t optVal);
int32_t taosAnalBufWriteOptFloat(SAnalyticBuf *pBuf, const char *optName, float optVal);
int32_t taosAnalBufWriteColMeta(SAnalyticBuf *pBuf, int32_t colIndex, int32_t colType, const char *colName);
int32_t taosAnalBufWriteDataBegin(SAnalyticBuf *pBuf);
int32_t taosAnalBufWriteColBegin(SAnalyticBuf *pBuf, int32_t colIndex);
int32_t taosAnalBufWriteColData(SAnalyticBuf *pBuf, int32_t colIndex, int32_t colType, void *colValue);
int32_t taosAnalBufWriteColEnd(SAnalyticBuf *pBuf, int32_t colIndex);
int32_t taosAnalBufWriteDataEnd(SAnalyticBuf *pBuf);
int32_t taosAnalBufClose(SAnalyticBuf *pBuf);
void taosAnalBufDestroy(SAnalyticBuf *pBuf);
int32_t tsosAnalyBufOpen(SAnalyticBuf *pBuf, int32_t numOfCols);
int32_t taosAnalyBufWriteOptStr(SAnalyticBuf *pBuf, const char *optName, const char *optVal);
int32_t taosAnalyBufWriteOptInt(SAnalyticBuf *pBuf, const char *optName, int64_t optVal);
int32_t taosAnalyBufWriteOptFloat(SAnalyticBuf *pBuf, const char *optName, float optVal);
int32_t taosAnalyBufWriteColMeta(SAnalyticBuf *pBuf, int32_t colIndex, int32_t colType, const char *colName);
int32_t taosAnalyBufWriteDataBegin(SAnalyticBuf *pBuf);
int32_t taosAnalyBufWriteColBegin(SAnalyticBuf *pBuf, int32_t colIndex);
int32_t taosAnalyBufWriteColData(SAnalyticBuf *pBuf, int32_t colIndex, int32_t colType, void *colValue);
int32_t taosAnalyBufWriteColEnd(SAnalyticBuf *pBuf, int32_t colIndex);
int32_t taosAnalyBufWriteDataEnd(SAnalyticBuf *pBuf);
int32_t taosAnalyBufClose(SAnalyticBuf *pBuf);
void taosAnalyBufDestroy(SAnalyticBuf *pBuf);
const char *taosAnalysisAlgoType(EAnalAlgoType algoType);
EAnalAlgoType taosAnalAlgoInt(const char *algoName);
const char *taosAnalAlgoUrlStr(EAnalAlgoType algoType);
EAnalAlgoType taosAnalyAlgoInt(const char *algoName);
const char *taosAnalyAlgoUrlStr(EAnalAlgoType algoType);
#ifdef __cplusplus
}

6
include/util/tdef.h
View File

@ -662,9 +662,9 @@ enum { RAND_ERR_MEMORY = 1, RAND_ERR_FILE = 2, RAND_ERR_NETWORK = 4 };
#define AUDIT_OPERATION_LEN 20
typedef enum {
ANAL_ALGO_TYPE_ANOMALY_DETECT = 0,
ANAL_ALGO_TYPE_FORECAST = 1,
ANAL_ALGO_TYPE_END,
ANALY_ALGO_TYPE_ANOMALY_DETECT = 0,
ANALY_ALGO_TYPE_FORECAST = 1,
ANALY_ALGO_TYPE_END,
} EAnalAlgoType;
typedef enum {

180
source/common/src/tanalytics.c
View File

@ -34,38 +34,38 @@ typedef struct {
} SCurlResp;
static SAlgoMgmt tsAlgos = {0};
static int32_t taosAnalBufGetCont(SAnalyticBuf *pBuf, char **ppCont, int64_t *pContLen);
static int32_t taosAnalyBufGetCont(SAnalyticBuf *pBuf, char **ppCont, int64_t *pContLen);
const char *taosAnalysisAlgoType(EAnalAlgoType type) {
switch (type) {
case ANAL_ALGO_TYPE_ANOMALY_DETECT:
case ANALY_ALGO_TYPE_ANOMALY_DETECT:
return "anomaly-detection";
case ANAL_ALGO_TYPE_FORECAST:
case ANALY_ALGO_TYPE_FORECAST:
return "forecast";
default:
return "unknown";
}
}
const char *taosAnalAlgoUrlStr(EAnalAlgoType type) {
const char *taosAnalyAlgoUrlStr(EAnalAlgoType type) {
switch (type) {
case ANAL_ALGO_TYPE_ANOMALY_DETECT:
case ANALY_ALGO_TYPE_ANOMALY_DETECT:
return "anomaly-detect";
case ANAL_ALGO_TYPE_FORECAST:
case ANALY_ALGO_TYPE_FORECAST:
return "forecast";
default:
return "unknown";
}
}
EAnalAlgoType taosAnalAlgoInt(const char *name) {
for (EAnalAlgoType i = 0; i < ANAL_ALGO_TYPE_END; ++i) {
EAnalAlgoType taosAnalyAlgoInt(const char *name) {
for (EAnalAlgoType i = 0; i < ANALY_ALGO_TYPE_END; ++i) {
if (strcasecmp(name, taosAnalysisAlgoType(i)) == 0) {
return i;
}
}
return ANAL_ALGO_TYPE_END;
return ANALY_ALGO_TYPE_END;
}
int32_t taosAnalyticsInit() {
@ -90,7 +90,7 @@ int32_t taosAnalyticsInit() {
return 0;
}
static void taosAnalFreeHash(SHashObj *hash) {
static void taosAnalyFreeHash(SHashObj *hash) {
void *pIter = taosHashIterate(hash, NULL);
while (pIter != NULL) {
SAnalyticsUrl *pUrl = (SAnalyticsUrl *)pIter;
@ -105,12 +105,12 @@ void taosAnalyticsCleanup() {
if (taosThreadMutexDestroy(&tsAlgos.lock) != 0) {
uError("failed to destroy anal lock");
}
taosAnalFreeHash(tsAlgos.hash);
taosAnalyFreeHash(tsAlgos.hash);
tsAlgos.hash = NULL;
uInfo("analysis env is cleaned up");
}
void taosAnalUpdate(int64_t newVer, SHashObj *pHash) {
void taosAnalyUpdate(int64_t newVer, SHashObj *pHash) {
if (newVer > tsAlgos.ver) {
if (taosThreadMutexLock(&tsAlgos.lock) == 0) {
SHashObj *hash = tsAlgos.hash;
@ -119,14 +119,14 @@ void taosAnalUpdate(int64_t newVer, SHashObj *pHash) {
if (taosThreadMutexUnlock(&tsAlgos.lock) != 0) {
uError("failed to unlock hash")
}
taosAnalFreeHash(hash);
taosAnalyFreeHash(hash);
}
} else {
taosAnalFreeHash(pHash);
taosAnalyFreeHash(pHash);
}
}
bool taosAnalGetOptStr(const char *option, const char *optName, char *optValue, int32_t optMaxLen) {
bool taosAnalyGetOptStr(const char *option, const char *optName, char *optValue, int32_t optMaxLen) {
char buf[TSDB_ANALYTIC_ALGO_OPTION_LEN] = {0};
char *pStart = NULL;
char *pEnd = NULL;
@ -163,7 +163,7 @@ bool taosAnalGetOptStr(const char *option, const char *optName, char *optValue,
return true;
}
bool taosAnalGetOptInt(const char *option, const char *optName, int64_t *optValue) {
bool taosAnalyGetOptInt(const char *option, const char *optName, int64_t *optValue) {
char buf[TSDB_ANALYTIC_ALGO_OPTION_LEN] = {0};
int32_t bufLen = tsnprintf(buf, sizeof(buf), "%s=", optName);
@ -177,7 +177,7 @@ bool taosAnalGetOptInt(const char *option, const char *optName, int64_t *optValu
}
}
int32_t taosAnalGetAlgoUrl(const char *algoName, EAnalAlgoType type, char *url, int32_t urlLen) {
int32_t taosAnalyGetAlgoUrl(const char *algoName, EAnalAlgoType type, char *url, int32_t urlLen) {
int32_t code = 0;
char name[TSDB_ANALYTIC_ALGO_KEY_LEN] = {0};
int32_t nameLen = 1 + tsnprintf(name, sizeof(name) - 1, "%d:%s", type, algoName);
@ -205,7 +205,7 @@ int32_t taosAnalGetAlgoUrl(const char *algoName, EAnalAlgoType type, char *url,
return code;
}
int64_t taosAnalGetVersion() { return tsAlgos.ver; }
int64_t taosAnalyGetVersion() { return tsAlgos.ver; }
static size_t taosCurlWriteData(char *pCont, size_t contLen, size_t nmemb, void *userdata) {
SCurlResp *pRsp = userdata;
@ -311,7 +311,7 @@ _OVER:
return code;
}
SJson *taosAnalSendReqRetJson(const char *url, EAnalHttpType type, SAnalyticBuf *pBuf) {
SJson *taosAnalySendReqRetJson(const char *url, EAnalHttpType type, SAnalyticBuf *pBuf) {
int32_t code = -1;
char *pCont = NULL;
int64_t contentLen;
@ -324,7 +324,7 @@ SJson *taosAnalSendReqRetJson(const char *url, EAnalHttpType type, SAnalyticBuf
goto _OVER;
}
} else {
code = taosAnalBufGetCont(pBuf, &pCont, &contentLen);
code = taosAnalyBufGetCont(pBuf, &pCont, &contentLen);
if (code != 0) {
terrno = code;
goto _OVER;
@ -356,7 +356,7 @@ _OVER:
return pJson;
}
static int32_t taosAnalJsonBufGetCont(const char *fileName, char **ppCont, int64_t *pContLen) {
static int32_t taosAnalyJsonBufGetCont(const char *fileName, char **ppCont, int64_t *pContLen) {
int32_t code = 0;
int64_t contLen;
char *pCont = NULL;
@ -395,7 +395,7 @@ _OVER:
return code;
}
static int32_t taosAnalJsonBufWriteOptInt(SAnalyticBuf *pBuf, const char *optName, int64_t optVal) {
static int32_t taosAnalyJsonBufWriteOptInt(SAnalyticBuf *pBuf, const char *optName, int64_t optVal) {
char buf[64] = {0};
int32_t bufLen = tsnprintf(buf, sizeof(buf), "\"%s\": %" PRId64 ",\n", optName, optVal);
if (taosWriteFile(pBuf->filePtr, buf, bufLen) != bufLen) {
@ -404,7 +404,7 @@ static int32_t taosAnalJsonBufWriteOptInt(SAnalyticBuf *pBuf, const char *optNam
return 0;
}
static int32_t taosAnalJsonBufWriteOptStr(SAnalyticBuf *pBuf, const char *optName, const char *optVal) {
static int32_t taosAnalyJsonBufWriteOptStr(SAnalyticBuf *pBuf, const char *optName, const char *optVal) {
char buf[128] = {0};
int32_t bufLen = tsnprintf(buf, sizeof(buf), "\"%s\": \"%s\",\n", optName, optVal);
if (taosWriteFile(pBuf->filePtr, buf, bufLen) != bufLen) {
@ -413,7 +413,7 @@ static int32_t taosAnalJsonBufWriteOptStr(SAnalyticBuf *pBuf, const char *optNam
return 0;
}
static int32_t taosAnalJsonBufWriteOptFloat(SAnalyticBuf *pBuf, const char *optName, float optVal) {
static int32_t taosAnalyJsonBufWriteOptFloat(SAnalyticBuf *pBuf, const char *optName, float optVal) {
char buf[128] = {0};
int32_t bufLen = tsnprintf(buf, sizeof(buf), "\"%s\": %f,\n", optName, optVal);
if (taosWriteFile(pBuf->filePtr, buf, bufLen) != bufLen) {
@ -422,7 +422,7 @@ static int32_t taosAnalJsonBufWriteOptFloat(SAnalyticBuf *pBuf, const char *optN
return 0;
}
static int32_t taosAnalJsonBufWriteStr(SAnalyticBuf *pBuf, const char *buf, int32_t bufLen) {
static int32_t taosAnalyJsonBufWriteStr(SAnalyticBuf *pBuf, const char *buf, int32_t bufLen) {
if (bufLen <= 0) {
bufLen = strlen(buf);
}
@ -432,7 +432,7 @@ static int32_t taosAnalJsonBufWriteStr(SAnalyticBuf *pBuf, const char *buf, int3
return 0;
}
static int32_t taosAnalJsonBufWriteStart(SAnalyticBuf *pBuf) { return taosAnalJsonBufWriteStr(pBuf, "{\n", 0); }
static int32_t taosAnalyJsonBufWriteStart(SAnalyticBuf *pBuf) { return taosAnalyJsonBufWriteStr(pBuf, "{\n", 0); }
static int32_t tsosAnalJsonBufOpen(SAnalyticBuf *pBuf, int32_t numOfCols) {
pBuf->filePtr = taosOpenFile(pBuf->fileName, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_TRUNC | TD_FILE_WRITE_THROUGH);
@ -445,7 +445,7 @@ static int32_t tsosAnalJsonBufOpen(SAnalyticBuf *pBuf, int32_t numOfCols) {
pBuf->numOfCols = numOfCols;
if (pBuf->bufType == ANALYTICS_BUF_TYPE_JSON) {
return taosAnalJsonBufWriteStart(pBuf);
return taosAnalyJsonBufWriteStart(pBuf);
}
for (int32_t i = 0; i < numOfCols; ++i) {
@ -458,16 +458,16 @@ static int32_t tsosAnalJsonBufOpen(SAnalyticBuf *pBuf, int32_t numOfCols) {
}
}
return taosAnalJsonBufWriteStart(pBuf);
return taosAnalyJsonBufWriteStart(pBuf);
}
static int32_t taosAnalJsonBufWriteColMeta(SAnalyticBuf *pBuf, int32_t colIndex, int32_t colType, const char *colName) {
static int32_t taosAnalyJsonBufWriteColMeta(SAnalyticBuf *pBuf, int32_t colIndex, int32_t colType, const char *colName) {
char buf[128] = {0};
bool first = (colIndex == 0);
bool last = (colIndex == pBuf->numOfCols - 1);
if (first) {
if (taosAnalJsonBufWriteStr(pBuf, "\"schema\": [\n", 0) != 0) {
if (taosAnalyJsonBufWriteStr(pBuf, "\"schema\": [\n", 0) != 0) {
return terrno;
}
}
@ -479,7 +479,7 @@ static int32_t taosAnalJsonBufWriteColMeta(SAnalyticBuf *pBuf, int32_t colIndex,
}
if (last) {
if (taosAnalJsonBufWriteStr(pBuf, "],\n", 0) != 0) {
if (taosAnalyJsonBufWriteStr(pBuf, "],\n", 0) != 0) {
return terrno;
}
}
@ -487,11 +487,11 @@ static int32_t taosAnalJsonBufWriteColMeta(SAnalyticBuf *pBuf, int32_t colIndex,
return 0;
}
static int32_t taosAnalJsonBufWriteDataBegin(SAnalyticBuf *pBuf) {
return taosAnalJsonBufWriteStr(pBuf, "\"data\": [\n", 0);
static int32_t taosAnalyJsonBufWriteDataBegin(SAnalyticBuf *pBuf) {
return taosAnalyJsonBufWriteStr(pBuf, "\"data\": [\n", 0);
}
static int32_t taosAnalJsonBufWriteStrUseCol(SAnalyticBuf *pBuf, const char *buf, int32_t bufLen, int32_t colIndex) {
static int32_t taosAnalyJsonBufWriteStrUseCol(SAnalyticBuf *pBuf, const char *buf, int32_t bufLen, int32_t colIndex) {
if (bufLen <= 0) {
bufLen = strlen(buf);
}
@ -511,20 +511,20 @@ static int32_t taosAnalJsonBufWriteStrUseCol(SAnalyticBuf *pBuf, const char *buf
return 0;
}
static int32_t taosAnalJsonBufWriteColBegin(SAnalyticBuf *pBuf, int32_t colIndex) {
return taosAnalJsonBufWriteStrUseCol(pBuf, "[\n", 0, colIndex);
static int32_t taosAnalyJsonBufWriteColBegin(SAnalyticBuf *pBuf, int32_t colIndex) {
return taosAnalyJsonBufWriteStrUseCol(pBuf, "[\n", 0, colIndex);
}
static int32_t taosAnalJsonBufWriteColEnd(SAnalyticBuf *pBuf, int32_t colIndex) {
static int32_t taosAnalyJsonBufWriteColEnd(SAnalyticBuf *pBuf, int32_t colIndex) {
if (colIndex == pBuf->numOfCols - 1) {
return taosAnalJsonBufWriteStrUseCol(pBuf, "\n]\n", 0, colIndex);
return taosAnalyJsonBufWriteStrUseCol(pBuf, "\n]\n", 0, colIndex);
} else {
return taosAnalJsonBufWriteStrUseCol(pBuf, "\n],\n", 0, colIndex);
return taosAnalyJsonBufWriteStrUseCol(pBuf, "\n],\n", 0, colIndex);
}
}
static int32_t taosAnalJsonBufWriteColData(SAnalyticBuf *pBuf, int32_t colIndex, int32_t colType, void *colValue) {
static int32_t taosAnalyJsonBufWriteColData(SAnalyticBuf *pBuf, int32_t colIndex, int32_t colType, void *colValue) {
char buf[64];
int32_t bufLen = 0;
@ -575,10 +575,10 @@ static int32_t taosAnalJsonBufWriteColData(SAnalyticBuf *pBuf, int32_t colIndex,
}
pBuf->pCols[colIndex].numOfRows++;
return taosAnalJsonBufWriteStrUseCol(pBuf, buf, bufLen, colIndex);
return taosAnalyJsonBufWriteStrUseCol(pBuf, buf, bufLen, colIndex);
}
static int32_t taosAnalJsonBufWriteDataEnd(SAnalyticBuf *pBuf) {
static int32_t taosAnalyJsonBufWriteDataEnd(SAnalyticBuf *pBuf) {
int32_t code = 0;
char *pCont = NULL;
int64_t contLen = 0;
@ -593,10 +593,10 @@ static int32_t taosAnalJsonBufWriteDataEnd(SAnalyticBuf *pBuf) {
code = taosCloseFile(&pCol->filePtr);
if (code != 0) return code;
code = taosAnalJsonBufGetCont(pBuf->pCols[i].fileName, &pCont, &contLen);
code = taosAnalyJsonBufGetCont(pBuf->pCols[i].fileName, &pCont, &contLen);
if (code != 0) return code;
code = taosAnalJsonBufWriteStr(pBuf, pCont, contLen);
code = taosAnalyJsonBufWriteStr(pBuf, pCont, contLen);
if (code != 0) return code;
taosMemoryFreeClear(pCont);
@ -604,18 +604,18 @@ static int32_t taosAnalJsonBufWriteDataEnd(SAnalyticBuf *pBuf) {
}
}
return taosAnalJsonBufWriteStr(pBuf, "],\n", 0);
return taosAnalyJsonBufWriteStr(pBuf, "],\n", 0);
}
static int32_t taosAnalJsonBufWriteEnd(SAnalyticBuf *pBuf) {
int32_t code = taosAnalJsonBufWriteOptInt(pBuf, "rows", pBuf->pCols[0].numOfRows);
static int32_t taosAnalyJsonBufWriteEnd(SAnalyticBuf *pBuf) {
int32_t code = taosAnalyJsonBufWriteOptInt(pBuf, "rows", pBuf->pCols[0].numOfRows);
if (code != 0) return code;
return taosAnalJsonBufWriteStr(pBuf, "\"protocol\": 1.0\n}", 0);
return taosAnalyJsonBufWriteStr(pBuf, "\"protocol\": 1.0\n}", 0);
}
int32_t taosAnalJsonBufClose(SAnalyticBuf *pBuf) {
int32_t code = taosAnalJsonBufWriteEnd(pBuf);
int32_t code = taosAnalyJsonBufWriteEnd(pBuf);
if (code != 0) return code;
if (pBuf->filePtr != NULL) {
@ -640,7 +640,7 @@ int32_t taosAnalJsonBufClose(SAnalyticBuf *pBuf) {
return 0;
}
void taosAnalBufDestroy(SAnalyticBuf *pBuf) {
void taosAnalyBufDestroy(SAnalyticBuf *pBuf) {
if (pBuf->fileName[0] != 0) {
if (pBuf->filePtr != NULL) (void)taosCloseFile(&pBuf->filePtr);
// taosRemoveFile(pBuf->fileName);
@ -664,7 +664,7 @@ void taosAnalBufDestroy(SAnalyticBuf *pBuf) {
pBuf->numOfCols = 0;
}
int32_t tsosAnalBufOpen(SAnalyticBuf *pBuf, int32_t numOfCols) {
int32_t tsosAnalyBufOpen(SAnalyticBuf *pBuf, int32_t numOfCols) {
if (pBuf->bufType == ANALYTICS_BUF_TYPE_JSON || pBuf->bufType == ANALYTICS_BUF_TYPE_JSON_COL) {
return tsosAnalJsonBufOpen(pBuf, numOfCols);
} else {
@ -672,79 +672,79 @@ int32_t tsosAnalBufOpen(SAnalyticBuf *pBuf, int32_t numOfCols) {
}
}
int32_t taosAnalBufWriteOptStr(SAnalyticBuf *pBuf, const char *optName, const char *optVal) {
int32_t taosAnalyBufWriteOptStr(SAnalyticBuf *pBuf, const char *optName, const char *optVal) {
if (pBuf->bufType == ANALYTICS_BUF_TYPE_JSON || pBuf->bufType == ANALYTICS_BUF_TYPE_JSON_COL) {
return taosAnalJsonBufWriteOptStr(pBuf, optName, optVal);
return taosAnalyJsonBufWriteOptStr(pBuf, optName, optVal);
} else {
return TSDB_CODE_ANA_BUF_INVALID_TYPE;
}
}
int32_t taosAnalBufWriteOptInt(SAnalyticBuf *pBuf, const char *optName, int64_t optVal) {
int32_t taosAnalyBufWriteOptInt(SAnalyticBuf *pBuf, const char *optName, int64_t optVal) {
if (pBuf->bufType == ANALYTICS_BUF_TYPE_JSON || pBuf->bufType == ANALYTICS_BUF_TYPE_JSON_COL) {
return taosAnalJsonBufWriteOptInt(pBuf, optName, optVal);
return taosAnalyJsonBufWriteOptInt(pBuf, optName, optVal);
} else {
return TSDB_CODE_ANA_BUF_INVALID_TYPE;
}
}
int32_t taosAnalBufWriteOptFloat(SAnalyticBuf *pBuf, const char *optName, float optVal) {
int32_t taosAnalyBufWriteOptFloat(SAnalyticBuf *pBuf, const char *optName, float optVal) {
if (pBuf->bufType == ANALYTICS_BUF_TYPE_JSON || pBuf->bufType == ANALYTICS_BUF_TYPE_JSON_COL) {
return taosAnalJsonBufWriteOptFloat(pBuf, optName, optVal);
return taosAnalyJsonBufWriteOptFloat(pBuf, optName, optVal);
} else {
return TSDB_CODE_ANA_BUF_INVALID_TYPE;
}
}
int32_t taosAnalBufWriteColMeta(SAnalyticBuf *pBuf, int32_t colIndex, int32_t colType, const char *colName) {
int32_t taosAnalyBufWriteColMeta(SAnalyticBuf *pBuf, int32_t colIndex, int32_t colType, const char *colName) {
if (pBuf->bufType == ANALYTICS_BUF_TYPE_JSON || pBuf->bufType == ANALYTICS_BUF_TYPE_JSON_COL) {
return taosAnalJsonBufWriteColMeta(pBuf, colIndex, colType, colName);
return taosAnalyJsonBufWriteColMeta(pBuf, colIndex, colType, colName);
} else {
return TSDB_CODE_ANA_BUF_INVALID_TYPE;
}
}
int32_t taosAnalBufWriteDataBegin(SAnalyticBuf *pBuf) {
int32_t taosAnalyBufWriteDataBegin(SAnalyticBuf *pBuf) {
if (pBuf->bufType == ANALYTICS_BUF_TYPE_JSON || pBuf->bufType == ANALYTICS_BUF_TYPE_JSON_COL) {
return taosAnalJsonBufWriteDataBegin(pBuf);
return taosAnalyJsonBufWriteDataBegin(pBuf);
} else {
return TSDB_CODE_ANA_BUF_INVALID_TYPE;
}
}
int32_t taosAnalBufWriteColBegin(SAnalyticBuf *pBuf, int32_t colIndex) {
int32_t taosAnalyBufWriteColBegin(SAnalyticBuf *pBuf, int32_t colIndex) {
if (pBuf->bufType == ANALYTICS_BUF_TYPE_JSON || pBuf->bufType == ANALYTICS_BUF_TYPE_JSON_COL) {
return taosAnalJsonBufWriteColBegin(pBuf, colIndex);
return taosAnalyJsonBufWriteColBegin(pBuf, colIndex);
} else {
return TSDB_CODE_ANA_BUF_INVALID_TYPE;
}
}
int32_t taosAnalBufWriteColData(SAnalyticBuf *pBuf, int32_t colIndex, int32_t colType, void *colValue) {
int32_t taosAnalyBufWriteColData(SAnalyticBuf *pBuf, int32_t colIndex, int32_t colType, void *colValue) {
if (pBuf->bufType == ANALYTICS_BUF_TYPE_JSON || pBuf->bufType == ANALYTICS_BUF_TYPE_JSON_COL) {
return taosAnalJsonBufWriteColData(pBuf, colIndex, colType, colValue);
return taosAnalyJsonBufWriteColData(pBuf, colIndex, colType, colValue);
} else {
return TSDB_CODE_ANA_BUF_INVALID_TYPE;
}
}
int32_t taosAnalBufWriteColEnd(SAnalyticBuf *pBuf, int32_t colIndex) {
int32_t taosAnalyBufWriteColEnd(SAnalyticBuf *pBuf, int32_t colIndex) {
if (pBuf->bufType == ANALYTICS_BUF_TYPE_JSON || pBuf->bufType == ANALYTICS_BUF_TYPE_JSON_COL) {
return taosAnalJsonBufWriteColEnd(pBuf, colIndex);
return taosAnalyJsonBufWriteColEnd(pBuf, colIndex);
} else {
return TSDB_CODE_ANA_BUF_INVALID_TYPE;
}
}
int32_t taosAnalBufWriteDataEnd(SAnalyticBuf *pBuf) {
int32_t taosAnalyBufWriteDataEnd(SAnalyticBuf *pBuf) {
if (pBuf->bufType == ANALYTICS_BUF_TYPE_JSON || pBuf->bufType == ANALYTICS_BUF_TYPE_JSON_COL) {
return taosAnalJsonBufWriteDataEnd(pBuf);
return taosAnalyJsonBufWriteDataEnd(pBuf);
} else {
return TSDB_CODE_ANA_BUF_INVALID_TYPE;
}
}
int32_t taosAnalBufClose(SAnalyticBuf *pBuf) {
int32_t taosAnalyBufClose(SAnalyticBuf *pBuf) {
if (pBuf->bufType == ANALYTICS_BUF_TYPE_JSON || pBuf->bufType == ANALYTICS_BUF_TYPE_JSON_COL) {
return taosAnalJsonBufClose(pBuf);
} else {
@ -752,12 +752,12 @@ int32_t taosAnalBufClose(SAnalyticBuf *pBuf) {
}
}
static int32_t taosAnalBufGetCont(SAnalyticBuf *pBuf, char **ppCont, int64_t *pContLen) {
static int32_t taosAnalyBufGetCont(SAnalyticBuf *pBuf, char **ppCont, int64_t *pContLen) {
*ppCont = NULL;
*pContLen = 0;
if (pBuf->bufType == ANALYTICS_BUF_TYPE_JSON || pBuf->bufType == ANALYTICS_BUF_TYPE_JSON_COL) {
return taosAnalJsonBufGetCont(pBuf->fileName, ppCont, pContLen);
return taosAnalyJsonBufGetCont(pBuf->fileName, ppCont, pContLen);
} else {
return TSDB_CODE_ANA_BUF_INVALID_TYPE;
}
@ -767,28 +767,28 @@ static int32_t taosAnalBufGetCont(SAnalyticBuf *pBuf, char **ppCont, int64_t *pC
int32_t taosAnalyticsInit() { return 0; }
void taosAnalyticsCleanup() {}
SJson *taosAnalSendReqRetJson(const char *url, EAnalHttpType type, SAnalyticBuf *pBuf) { return NULL; }
SJson *taosAnalySendReqRetJson(const char *url, EAnalHttpType type, SAnalyticBuf *pBuf) { return NULL; }
int32_t taosAnalGetAlgoUrl(const char *algoName, EAnalAlgoType type, char *url, int32_t urlLen) { return 0; }
bool taosAnalGetOptStr(const char *option, const char *optName, char *optValue, int32_t optMaxLen) { return true; }
bool taosAnalGetOptInt(const char *option, const char *optName, int64_t *optValue) { return true; }
int64_t taosAnalGetVersion() { return 0; }
void taosAnalUpdate(int64_t newVer, SHashObj *pHash) {}
int32_t taosAnalyGetAlgoUrl(const char *algoName, EAnalAlgoType type, char *url, int32_t urlLen) { return 0; }
bool taosAnalyGetOptStr(const char *option, const char *optName, char *optValue, int32_t optMaxLen) { return true; }
bool taosAnalyGetOptInt(const char *option, const char *optName, int64_t *optValue) { return true; }
int64_t taosAnalyGetVersion() { return 0; }
void taosAnalyUpdate(int64_t newVer, SHashObj *pHash) {}
int32_t tsosAnalBufOpen(SAnalyticBuf *pBuf, int32_t numOfCols) { return 0; }
int32_t taosAnalBufWriteOptStr(SAnalyticBuf *pBuf, const char *optName, const char *optVal) { return 0; }
int32_t taosAnalBufWriteOptInt(SAnalyticBuf *pBuf, const char *optName, int64_t optVal) { return 0; }
int32_t taosAnalBufWriteOptFloat(SAnalyticBuf *pBuf, const char *optName, float optVal) { return 0; }
int32_t taosAnalBufWriteColMeta(SAnalyticBuf *pBuf, int32_t colIndex, int32_t colType, const char *colName) {
int32_t tsosAnalyBufOpen(SAnalyticBuf *pBuf, int32_t numOfCols) { return 0; }
int32_t taosAnalyBufWriteOptStr(SAnalyticBuf *pBuf, const char *optName, const char *optVal) { return 0; }
int32_t taosAnalyBufWriteOptInt(SAnalyticBuf *pBuf, const char *optName, int64_t optVal) { return 0; }
int32_t taosAnalyBufWriteOptFloat(SAnalyticBuf *pBuf, const char *optName, float optVal) { return 0; }
int32_t taosAnalyBufWriteColMeta(SAnalyticBuf *pBuf, int32_t colIndex, int32_t colType, const char *colName) {
return 0;
}
int32_t taosAnalBufWriteDataBegin(SAnalyticBuf *pBuf) { return 0; }
int32_t taosAnalBufWriteColBegin(SAnalyticBuf *pBuf, int32_t colIndex) { return 0; }
int32_t taosAnalBufWriteColData(SAnalyticBuf *pBuf, int32_t colIndex, int32_t colType, void *colValue) { return 0; }
int32_t taosAnalBufWriteColEnd(SAnalyticBuf *pBuf, int32_t colIndex) { return 0; }
int32_t taosAnalBufWriteDataEnd(SAnalyticBuf *pBuf) { return 0; }
int32_t taosAnalBufClose(SAnalyticBuf *pBuf) { return 0; }
void taosAnalBufDestroy(SAnalyticBuf *pBuf) {}
int32_t taosAnalyBufWriteDataBegin(SAnalyticBuf *pBuf) { return 0; }
int32_t taosAnalyBufWriteColBegin(SAnalyticBuf *pBuf, int32_t colIndex) { return 0; }
int32_t taosAnalyBufWriteColData(SAnalyticBuf *pBuf, int32_t colIndex, int32_t colType, void *colValue) { return 0; }
int32_t taosAnalyBufWriteColEnd(SAnalyticBuf *pBuf, int32_t colIndex) { return 0; }
int32_t taosAnalyBufWriteDataEnd(SAnalyticBuf *pBuf) { return 0; }
int32_t taosAnalyBufClose(SAnalyticBuf *pBuf) { return 0; }
void taosAnalyBufDestroy(SAnalyticBuf *pBuf) {}
const char *taosAnalysisAlgoType(EAnalAlgoType algoType) { return 0; }
EAnalAlgoType taosAnalAlgoInt(const char *algoName) { return 0; }

4
source/dnode/mgmt/mgmt_dnode/src/dmHandle.c
View File

@ -94,7 +94,7 @@ static void dmMayShouldUpdateIpWhiteList(SDnodeMgmt *pMgmt, int64_t ver) {
static void dmMayShouldUpdateAnalFunc(SDnodeMgmt *pMgmt, int64_t newVer) {
int32_t code = 0;
int64_t oldVer = taosAnalGetVersion();
int64_t oldVer = taosAnalyGetVersion();
if (oldVer == newVer) return;
dDebug("analysis on dnode ver:%" PRId64 ", status ver:%" PRId64, oldVer, newVer);
@ -233,7 +233,7 @@ void dmSendStatusReq(SDnodeMgmt *pMgmt) {
req.statusSeq = pMgmt->statusSeq;
req.ipWhiteVer = pMgmt->pData->ipWhiteVer;
req.analVer = taosAnalGetVersion();
req.analVer = taosAnalyGetVersion();
int32_t contLen = tSerializeSStatusReq(NULL, 0, &req);
if (contLen < 0) {

2
source/dnode/mgmt/node_mgmt/src/dmTransport.c
View File

@ -119,7 +119,7 @@ static bool dmIsForbiddenIp(int8_t forbidden, char *user, uint32_t clientIp) {
static void dmUpdateAnalFunc(SDnodeData *pData, void *pTrans, SRpcMsg *pRpc) {
SRetrieveAnalAlgoRsp rsp = {0};
if (tDeserializeRetrieveAnalAlgoRsp(pRpc->pCont, pRpc->contLen, &rsp) == 0) {
taosAnalUpdate(rsp.ver, rsp.hash);
taosAnalyUpdate(rsp.ver, rsp.hash);
rsp.hash = NULL;
}
tFreeRetrieveAnalAlgoRsp(&rsp);

32
source/dnode/mnode/impl/src/mndAnode.c
View File

@ -649,13 +649,19 @@ void mndRetrieveAlgoList(SMnode* pMnode, SArray* pFc, SArray* pAd) {
break;
}
if (pObj->numOfAlgos >= ANAL_ALGO_TYPE_END) {
if (pObj->algos[ANAL_ALGO_TYPE_ANOMALY_DETECT] != NULL) {
taosArrayAddAll(pAd, pObj->algos[ANAL_ALGO_TYPE_ANOMALY_DETECT]);
if (pObj->numOfAlgos >= ANALY_ALGO_TYPE_END) {
if (pObj->algos[ANALY_ALGO_TYPE_ANOMALY_DETECT] != NULL) {
void* p = taosArrayAddAll(pAd, pObj->algos[ANALY_ALGO_TYPE_ANOMALY_DETECT]);
if (p == NULL) {
mError("failed to add retrieved anomaly-detection algorithms, code:%s", tstrerror(terrno));
}
}
if (pObj->algos[ANAL_ALGO_TYPE_FORECAST] != NULL) {
taosArrayAddAll(pFc, pObj->algos[ANAL_ALGO_TYPE_FORECAST]);
if (pObj->algos[ANALY_ALGO_TYPE_FORECAST] != NULL) {
void* p = taosArrayAddAll(pFc, pObj->algos[ANALY_ALGO_TYPE_FORECAST]);
if (p == NULL) {
mError("failed to add retrieved forecast algorithms, code:%s", tstrerror(terrno));
}
}
}
@ -738,11 +744,11 @@ static int32_t mndDecodeAlgoList(SJson *pJson, SAnodeObj *pObj) {
if (details == NULL) return TSDB_CODE_INVALID_JSON_FORMAT;
int32_t numOfDetails = tjsonGetArraySize(details);
pObj->algos = taosMemoryCalloc(ANAL_ALGO_TYPE_END, sizeof(SArray *));
pObj->algos = taosMemoryCalloc(ANALY_ALGO_TYPE_END, sizeof(SArray *));
if (pObj->algos == NULL) return TSDB_CODE_OUT_OF_MEMORY;
pObj->numOfAlgos = ANAL_ALGO_TYPE_END;
for (int32_t i = 0; i < ANAL_ALGO_TYPE_END; ++i) {
pObj->numOfAlgos = ANALY_ALGO_TYPE_END;
for (int32_t i = 0; i < ANALY_ALGO_TYPE_END; ++i) {
pObj->algos[i] = taosArrayInit(4, sizeof(SAnodeAlgo));
if (pObj->algos[i] == NULL) return TSDB_CODE_OUT_OF_MEMORY;
}
@ -753,8 +759,8 @@ static int32_t mndDecodeAlgoList(SJson *pJson, SAnodeObj *pObj) {
code = tjsonGetStringValue2(detail, "type", buf, sizeof(buf));
if (code < 0) return TSDB_CODE_INVALID_JSON_FORMAT;
EAnalAlgoType type = taosAnalAlgoInt(buf);
if (type < 0 || type >= ANAL_ALGO_TYPE_END) return TSDB_CODE_MND_ANODE_INVALID_ALGO_TYPE;
EAnalAlgoType type = taosAnalyAlgoInt(buf);
if (type < 0 || type >= ANALY_ALGO_TYPE_END) return TSDB_CODE_MND_ANODE_INVALID_ALGO_TYPE;
SJson *algos = tjsonGetObjectItem(detail, "algo");
if (algos == NULL) return TSDB_CODE_INVALID_JSON_FORMAT;
@ -783,7 +789,7 @@ static int32_t mndGetAnodeAlgoList(const char *url, SAnodeObj *pObj) {
char anodeUrl[TSDB_ANALYTIC_ANODE_URL_LEN + 1] = {0};
snprintf(anodeUrl, TSDB_ANALYTIC_ANODE_URL_LEN, "%s/%s", url, "list");
SJson *pJson = taosAnalSendReqRetJson(anodeUrl, ANALYTICS_HTTP_TYPE_GET, NULL);
SJson *pJson = taosAnalySendReqRetJson(anodeUrl, ANALYTICS_HTTP_TYPE_GET, NULL);
if (pJson == NULL) return terrno;
int32_t code = mndDecodeAlgoList(pJson, pObj);
@ -799,7 +805,7 @@ static int32_t mndGetAnodeStatus(SAnodeObj *pObj, char *status, int32_t statusLe
char anodeUrl[TSDB_ANALYTIC_ANODE_URL_LEN + 1] = {0};
snprintf(anodeUrl, TSDB_ANALYTIC_ANODE_URL_LEN, "%s/%s", pObj->url, "status");
SJson *pJson = taosAnalSendReqRetJson(anodeUrl, ANALYTICS_HTTP_TYPE_GET, NULL);
SJson *pJson = taosAnalySendReqRetJson(anodeUrl, ANALYTICS_HTTP_TYPE_GET, NULL);
if (pJson == NULL) return terrno;
code = tjsonGetDoubleValue(pJson, "protocol", &tmp);
@ -881,7 +887,7 @@ static int32_t mndProcessAnalAlgoReq(SRpcMsg *pReq) {
}
url.urlLen = 1 + tsnprintf(url.url, TSDB_ANALYTIC_ANODE_URL_LEN + TSDB_ANALYTIC_ALGO_TYPE_LEN, "%s/%s", pAnode->url,
taosAnalAlgoUrlStr(url.type));
taosAnalyAlgoUrlStr(url.type));
if (taosHashPut(rsp.hash, name, nameLen, &url, sizeof(SAnalyticsUrl)) != 0) {
taosMemoryFree(url.url);
sdbRelease(pSdb, pAnode);

2
source/dnode/mnode/impl/src/mndSma.c
View File

@ -1502,7 +1502,7 @@ static int32_t mndRetrieveSma(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBloc
// sma and tag index comm func
static int32_t mndProcessDropIdxReq(SRpcMsg *pReq) {
int ret = mndProcessDropSmaReq(pReq);
if (terrno == TSDB_CODE_MND_TAG_INDEX_ALREADY_EXIST) {
if (ret == TSDB_CODE_MND_TAG_INDEX_ALREADY_EXIST || ret == TSDB_CODE_MND_SMA_NOT_EXIST) {
terrno = 0;
ret = mndProcessDropTagIdxReq(pReq);
}

50
source/libs/executor/src/anomalywindowoperator.c
View File

@ -77,13 +77,13 @@ int32_t createAnomalywindowOperatorInfo(SOperatorInfo* downstream, SPhysiNode* p
goto _error;
}
if (!taosAnalGetOptStr(pAnomalyNode->anomalyOpt, "algo", pInfo->algoName, sizeof(pInfo->algoName))) {
if (!taosAnalyGetOptStr(pAnomalyNode->anomalyOpt, "algo", pInfo->algoName, sizeof(pInfo->algoName))) {
qError("%s failed to get anomaly_window algorithm name from %s", id, pAnomalyNode->anomalyOpt);
code = TSDB_CODE_ANA_ALGO_NOT_FOUND;
goto _error;
}
if (taosAnalGetAlgoUrl(pInfo->algoName, ANAL_ALGO_TYPE_ANOMALY_DETECT, pInfo->algoUrl, sizeof(pInfo->algoUrl)) != 0) {
if (taosAnalyGetAlgoUrl(pInfo->algoName, ANALY_ALGO_TYPE_ANOMALY_DETECT, pInfo->algoUrl, sizeof(pInfo->algoUrl)) != 0) {
qError("%s failed to get anomaly_window algorithm url from %s", id, pInfo->algoName);
code = TSDB_CODE_ANA_ALGO_NOT_LOAD;
goto _error;
@ -265,7 +265,7 @@ static void anomalyDestroyOperatorInfo(void* param) {
}
static int32_t anomalyCacheBlock(SAnomalyWindowOperatorInfo* pInfo, SSDataBlock* pSrc) {
if (pInfo->anomalySup.cachedRows > ANAL_ANOMALY_WINDOW_MAX_ROWS) {
if (pInfo->anomalySup.cachedRows > ANALY_ANOMALY_WINDOW_MAX_ROWS) {
return TSDB_CODE_ANA_ANODE_TOO_MANY_ROWS;
}
@ -364,35 +364,35 @@ static int32_t anomalyAnalysisWindow(SOperatorInfo* pOperator) {
SAnomalyWindowOperatorInfo* pInfo = pOperator->info;
SAnomalyWindowSupp* pSupp = &pInfo->anomalySup;
SJson* pJson = NULL;
SAnalyticBuf analBuf = {.bufType = ANALYTICS_BUF_TYPE_JSON};
SAnalyticBuf analyBuf = {.bufType = ANALYTICS_BUF_TYPE_JSON};
char dataBuf[64] = {0};
int32_t code = 0;
int64_t ts = 0;
int32_t lino = 0;
const char* pId = GET_TASKID(pOperator->pTaskInfo);
snprintf(analBuf.fileName, sizeof(analBuf.fileName), "%s/tdengine-anomaly-%" PRId64 "-%" PRId64, tsTempDir, ts,
snprintf(analyBuf.fileName, sizeof(analyBuf.fileName), "%s/tdengine-anomaly-%" PRId64 "-%" PRId64, tsTempDir, ts,
pSupp->groupId);
code = tsosAnalBufOpen(&analBuf, 2);
code = tsosAnalyBufOpen(&analyBuf, 2);
QUERY_CHECK_CODE(code, lino, _OVER);
const char* prec = TSDB_TIME_PRECISION_MILLI_STR;
if (pInfo->anomalyCol.precision == TSDB_TIME_PRECISION_MICRO) prec = TSDB_TIME_PRECISION_MICRO_STR;
if (pInfo->anomalyCol.precision == TSDB_TIME_PRECISION_NANO) prec = TSDB_TIME_PRECISION_NANO_STR;
code = taosAnalBufWriteColMeta(&analBuf, 0, TSDB_DATA_TYPE_TIMESTAMP, "ts");
code = taosAnalyBufWriteColMeta(&analyBuf, 0, TSDB_DATA_TYPE_TIMESTAMP, "ts");
QUERY_CHECK_CODE(code, lino, _OVER);
code = taosAnalBufWriteColMeta(&analBuf, 1, pInfo->anomalyCol.type, "val");
code = taosAnalyBufWriteColMeta(&analyBuf, 1, pInfo->anomalyCol.type, "val");
QUERY_CHECK_CODE(code, lino, _OVER);
code = taosAnalBufWriteDataBegin(&analBuf);
code = taosAnalyBufWriteDataBegin(&analyBuf);
QUERY_CHECK_CODE(code, lino, _OVER);
int32_t numOfBlocks = (int32_t)taosArrayGetSize(pSupp->blocks);
// timestamp
code = taosAnalBufWriteColBegin(&analBuf, 0);
code = taosAnalyBufWriteColBegin(&analyBuf, 0);
QUERY_CHECK_CODE(code, lino, _OVER);
for (int32_t i = 0; i < numOfBlocks; ++i) {
@ -401,16 +401,16 @@ static int32_t anomalyAnalysisWindow(SOperatorInfo* pOperator) {
SColumnInfoData* pTsCol = taosArrayGet(pBlock->pDataBlock, pInfo->tsSlotId);
if (pTsCol == NULL) break;
for (int32_t j = 0; j < pBlock->info.rows; ++j) {
code = taosAnalBufWriteColData(&analBuf, 0, TSDB_DATA_TYPE_TIMESTAMP, &((TSKEY*)pTsCol->pData)[j]);
code = taosAnalyBufWriteColData(&analyBuf, 0, TSDB_DATA_TYPE_TIMESTAMP, &((TSKEY*)pTsCol->pData)[j]);
QUERY_CHECK_CODE(code, lino, _OVER);
}
}
code = taosAnalBufWriteColEnd(&analBuf, 0);
code = taosAnalyBufWriteColEnd(&analyBuf, 0);
QUERY_CHECK_CODE(code, lino, _OVER);
// data
code = taosAnalBufWriteColBegin(&analBuf, 1);
code = taosAnalyBufWriteColBegin(&analyBuf, 1);
QUERY_CHECK_CODE(code, lino, _OVER);
for (int32_t i = 0; i < numOfBlocks; ++i) {
@ -420,38 +420,38 @@ static int32_t anomalyAnalysisWindow(SOperatorInfo* pOperator) {
if (pValCol == NULL) break;
for (int32_t j = 0; j < pBlock->info.rows; ++j) {
code = taosAnalBufWriteColData(&analBuf, 1, pValCol->info.type, colDataGetData(pValCol, j));
code = taosAnalyBufWriteColData(&analyBuf, 1, pValCol->info.type, colDataGetData(pValCol, j));
QUERY_CHECK_CODE(code, lino, _OVER);
}
}
code = taosAnalBufWriteColEnd(&analBuf, 1);
code = taosAnalyBufWriteColEnd(&analyBuf, 1);
QUERY_CHECK_CODE(code, lino, _OVER);
code = taosAnalBufWriteDataEnd(&analBuf);
code = taosAnalyBufWriteDataEnd(&analyBuf);
QUERY_CHECK_CODE(code, lino, _OVER);
code = taosAnalBufWriteOptStr(&analBuf, "option", pInfo->anomalyOpt);
code = taosAnalyBufWriteOptStr(&analyBuf, "option", pInfo->anomalyOpt);
QUERY_CHECK_CODE(code, lino, _OVER);
code = taosAnalBufWriteOptStr(&analBuf, "algo", pInfo->algoName);
code = taosAnalyBufWriteOptStr(&analyBuf, "algo", pInfo->algoName);
QUERY_CHECK_CODE(code, lino, _OVER);
code = taosAnalBufWriteOptStr(&analBuf, "prec", prec);
code = taosAnalyBufWriteOptStr(&analyBuf, "prec", prec);
QUERY_CHECK_CODE(code, lino, _OVER);
int64_t wncheck = ANAL_FORECAST_DEFAULT_WNCHECK;
bool hasWncheck = taosAnalGetOptInt(pInfo->anomalyOpt, "wncheck", &wncheck);
int64_t wncheck = ANALY_FORECAST_DEFAULT_WNCHECK;
bool hasWncheck = taosAnalyGetOptInt(pInfo->anomalyOpt, "wncheck", &wncheck);
if (!hasWncheck) {
qDebug("anomaly_window wncheck not found from %s, use default:%" PRId64, pInfo->anomalyOpt, wncheck);
}
code = taosAnalBufWriteOptInt(&analBuf, "wncheck", wncheck);
code = taosAnalyBufWriteOptInt(&analyBuf, "wncheck", wncheck);
QUERY_CHECK_CODE(code, lino, _OVER);
code = taosAnalBufClose(&analBuf);
code = taosAnalyBufClose(&analyBuf);
QUERY_CHECK_CODE(code, lino, _OVER);
pJson = taosAnalSendReqRetJson(pInfo->algoUrl, ANALYTICS_HTTP_TYPE_POST, &analBuf);
pJson = taosAnalySendReqRetJson(pInfo->algoUrl, ANALYTICS_HTTP_TYPE_POST, &analyBuf);
if (pJson == NULL) {
code = terrno;
goto _OVER;
@ -464,7 +464,7 @@ _OVER:
qError("%s failed to analysis window since %s, lino:%d", pId, tstrerror(code), lino);
}
taosAnalBufDestroy(&analBuf);
taosAnalyBufDestroy(&analyBuf);
if (pJson != NULL) tjsonDelete(pJson);
return code;
}

107
source/libs/executor/src/forecastoperator.c
View File

@ -46,7 +46,7 @@ typedef struct {
int16_t inputValSlot;
int8_t inputValType;
int8_t inputPrecision;
SAnalyticBuf analBuf;
SAnalyticBuf analyBuf;
} SForecastSupp;
typedef struct SForecastOperatorInfo {
@ -74,12 +74,12 @@ static FORCE_INLINE int32_t forecastEnsureBlockCapacity(SSDataBlock* pBlock, int
static int32_t forecastCacheBlock(SForecastSupp* pSupp, SSDataBlock* pBlock, const char* id) {
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
SAnalyticBuf* pBuf = &pSupp->analBuf;
SAnalyticBuf* pBuf = &pSupp->analyBuf;
if (pSupp->cachedRows > ANAL_FORECAST_MAX_ROWS) {
if (pSupp->cachedRows > ANALY_FORECAST_MAX_HISTORY_ROWS) {
code = TSDB_CODE_ANA_ANODE_TOO_MANY_ROWS;
qError("%s rows:%" PRId64 " for forecast cache, error happens, code:%s, upper limit:%d", id, pSupp->cachedRows,
tstrerror(code), ANAL_FORECAST_MAX_ROWS);
tstrerror(code), ANALY_FORECAST_MAX_HISTORY_ROWS);
return code;
}
@ -99,13 +99,13 @@ static int32_t forecastCacheBlock(SForecastSupp* pSupp, SSDataBlock* pBlock, con
pSupp->maxTs = MAX(pSupp->maxTs, ts);
pSupp->numOfRows++;
code = taosAnalBufWriteColData(pBuf, 0, TSDB_DATA_TYPE_TIMESTAMP, &ts);
code = taosAnalyBufWriteColData(pBuf, 0, TSDB_DATA_TYPE_TIMESTAMP, &ts);
if (TSDB_CODE_SUCCESS != code) {
qError("%s failed to write ts in buf, code:%s", id, tstrerror(code));
return code;
}
code = taosAnalBufWriteColData(pBuf, 1, valType, val);
code = taosAnalyBufWriteColData(pBuf, 1, valType, val);
if (TSDB_CODE_SUCCESS != code) {
qError("%s failed to write val in buf, code:%s", id, tstrerror(code));
return code;
@ -115,81 +115,88 @@ static int32_t forecastCacheBlock(SForecastSupp* pSupp, SSDataBlock* pBlock, con
return 0;
}
static int32_t forecastCloseBuf(SForecastSupp* pSupp) {
SAnalyticBuf* pBuf = &pSupp->analBuf;
static int32_t forecastCloseBuf(SForecastSupp* pSupp, const char* id) {
SAnalyticBuf* pBuf = &pSupp->analyBuf;
int32_t code = 0;
for (int32_t i = 0; i < 2; ++i) {
code = taosAnalBufWriteColEnd(pBuf, i);
code = taosAnalyBufWriteColEnd(pBuf, i);
if (code != 0) return code;
}
code = taosAnalBufWriteDataEnd(pBuf);
code = taosAnalyBufWriteDataEnd(pBuf);
if (code != 0) return code;
code = taosAnalBufWriteOptStr(pBuf, "option", pSupp->algoOpt);
code = taosAnalyBufWriteOptStr(pBuf, "option", pSupp->algoOpt);
if (code != 0) return code;
code = taosAnalBufWriteOptStr(pBuf, "algo", pSupp->algoName);
code = taosAnalyBufWriteOptStr(pBuf, "algo", pSupp->algoName);
if (code != 0) return code;
const char* prec = TSDB_TIME_PRECISION_MILLI_STR;
if (pSupp->inputPrecision == TSDB_TIME_PRECISION_MICRO) prec = TSDB_TIME_PRECISION_MICRO_STR;
if (pSupp->inputPrecision == TSDB_TIME_PRECISION_NANO) prec = TSDB_TIME_PRECISION_NANO_STR;
code = taosAnalBufWriteOptStr(pBuf, "prec", prec);
code = taosAnalyBufWriteOptStr(pBuf, "prec", prec);
if (code != 0) return code;
int64_t wncheck = ANAL_FORECAST_DEFAULT_WNCHECK;
bool hasWncheck = taosAnalGetOptInt(pSupp->algoOpt, "wncheck", &wncheck);
int64_t wncheck = ANALY_FORECAST_DEFAULT_WNCHECK;
bool hasWncheck = taosAnalyGetOptInt(pSupp->algoOpt, "wncheck", &wncheck);
if (!hasWncheck) {
qDebug("forecast wncheck not found from %s, use default:%" PRId64, pSupp->algoOpt, wncheck);
qDebug("%s forecast wncheck not found from %s, use default:%" PRId64, id, pSupp->algoOpt, wncheck);
}
code = taosAnalBufWriteOptInt(pBuf, "wncheck", wncheck);
code = taosAnalyBufWriteOptInt(pBuf, "wncheck", wncheck);
if (code != 0) return code;
bool noConf = (pSupp->resHighSlot == -1 && pSupp->resLowSlot == -1);
code = taosAnalBufWriteOptInt(pBuf, "return_conf", !noConf);
code = taosAnalyBufWriteOptInt(pBuf, "return_conf", !noConf);
if (code != 0) return code;
pSupp->optRows = ANAL_FORECAST_DEFAULT_ROWS;
bool hasRows = taosAnalGetOptInt(pSupp->algoOpt, "rows", &pSupp->optRows);
pSupp->optRows = ANALY_FORECAST_DEFAULT_ROWS;
bool hasRows = taosAnalyGetOptInt(pSupp->algoOpt, "rows", &pSupp->optRows);
if (!hasRows) {
qDebug("forecast rows not found from %s, use default:%" PRId64, pSupp->algoOpt, pSupp->optRows);
qDebug("%s forecast rows not found from %s, use default:%" PRId64, id, pSupp->algoOpt, pSupp->optRows);
}
code = taosAnalBufWriteOptInt(pBuf, "forecast_rows", pSupp->optRows);
if (pSupp->optRows > ANALY_MAX_FC_ROWS) {
qError("%s required too many forecast rows, max allowed:%d, required:%" PRId64, id, ANALY_MAX_FC_ROWS,
pSupp->optRows);
return TSDB_CODE_ANA_ANODE_TOO_MANY_ROWS;
}
code = taosAnalyBufWriteOptInt(pBuf, "forecast_rows", pSupp->optRows);
if (code != 0) return code;
int64_t conf = ANAL_FORECAST_DEFAULT_CONF;
bool hasConf = taosAnalGetOptInt(pSupp->algoOpt, "conf", &conf);
int64_t conf = ANALY_FORECAST_DEFAULT_CONF;
bool hasConf = taosAnalyGetOptInt(pSupp->algoOpt, "conf", &conf);
if (!hasConf) {
qDebug("forecast conf not found from %s, use default:%" PRId64, pSupp->algoOpt, conf);
qDebug("%s forecast conf not found from %s, use default:%" PRId64, id, pSupp->algoOpt, conf);
}
code = taosAnalBufWriteOptInt(pBuf, "conf", conf);
code = taosAnalyBufWriteOptInt(pBuf, "conf", conf);
if (code != 0) return code;
int32_t len = strlen(pSupp->algoOpt);
int64_t every = (pSupp->maxTs - pSupp->minTs) / (pSupp->numOfRows - 1);
int64_t start = pSupp->maxTs + every;
bool hasStart = taosAnalGetOptInt(pSupp->algoOpt, "start", &start);
bool hasStart = taosAnalyGetOptInt(pSupp->algoOpt, "start", &start);
if (!hasStart) {
qDebug("forecast start not found from %s, use %" PRId64, pSupp->algoOpt, start);
qDebug("%s forecast start not found from %s, use %" PRId64, id, pSupp->algoOpt, start);
}
code = taosAnalBufWriteOptInt(pBuf, "start", start);
code = taosAnalyBufWriteOptInt(pBuf, "start", start);
if (code != 0) return code;
bool hasEvery = taosAnalGetOptInt(pSupp->algoOpt, "every", &every);
bool hasEvery = taosAnalyGetOptInt(pSupp->algoOpt, "every", &every);
if (!hasEvery) {
qDebug("forecast every not found from %s, use %" PRId64, pSupp->algoOpt, every);
qDebug("%s forecast every not found from %s, use %" PRId64, id, pSupp->algoOpt, every);
}
code = taosAnalBufWriteOptInt(pBuf, "every", every);
code = taosAnalyBufWriteOptInt(pBuf, "every", every);
if (code != 0) return code;
code = taosAnalBufClose(pBuf);
code = taosAnalyBufClose(pBuf);
return code;
}
static int32_t forecastAnalysis(SForecastSupp* pSupp, SSDataBlock* pBlock, const char* pId) {
SAnalyticBuf* pBuf = &pSupp->analBuf;
SAnalyticBuf* pBuf = &pSupp->analyBuf;
int32_t resCurRow = pBlock->info.rows;
int8_t tmpI8;
int16_t tmpI16;
@ -209,7 +216,7 @@ static int32_t forecastAnalysis(SForecastSupp* pSupp, SSDataBlock* pBlock, const
SColumnInfoData* pResHighCol =
(pSupp->resHighSlot != -1 ? taosArrayGet(pBlock->pDataBlock, pSupp->resHighSlot) : NULL);
SJson* pJson = taosAnalSendReqRetJson(pSupp->algoUrl, ANALYTICS_HTTP_TYPE_POST, pBuf);
SJson* pJson = taosAnalySendReqRetJson(pSupp->algoUrl, ANALYTICS_HTTP_TYPE_POST, pBuf);
if (pJson == NULL) {
return terrno;
}
@ -356,9 +363,9 @@ _OVER:
static int32_t forecastAggregateBlocks(SForecastSupp* pSupp, SSDataBlock* pResBlock, const char* pId) {
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
SAnalyticBuf* pBuf = &pSupp->analBuf;
SAnalyticBuf* pBuf = &pSupp->analyBuf;
code = forecastCloseBuf(pSupp);
code = forecastCloseBuf(pSupp, pId);
QUERY_CHECK_CODE(code, lino, _end);
code = forecastEnsureBlockCapacity(pResBlock, 1);
@ -371,7 +378,7 @@ static int32_t forecastAggregateBlocks(SForecastSupp* pSupp, SSDataBlock* pResBl
_end:
pSupp->numOfBlocks = 0;
taosAnalBufDestroy(&pSupp->analBuf);
taosAnalyBufDestroy(&pSupp->analyBuf);
return code;
}
@ -382,7 +389,7 @@ static int32_t forecastNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {
SForecastOperatorInfo* pInfo = pOperator->info;
SSDataBlock* pResBlock = pInfo->pRes;
SForecastSupp* pSupp = &pInfo->forecastSupp;
SAnalyticBuf* pBuf = &pSupp->analBuf;
SAnalyticBuf* pBuf = &pSupp->analyBuf;
int64_t st = taosGetTimestampUs();
int32_t numOfBlocks = pSupp->numOfBlocks;
const char* pId = GET_TASKID(pOperator->pTaskInfo);
@ -525,12 +532,12 @@ static int32_t forecastParseAlgo(SForecastSupp* pSupp) {
pSupp->minTs = INT64_MAX;
pSupp->numOfRows = 0;
if (!taosAnalGetOptStr(pSupp->algoOpt, "algo", pSupp->algoName, sizeof(pSupp->algoName))) {
if (!taosAnalyGetOptStr(pSupp->algoOpt, "algo", pSupp->algoName, sizeof(pSupp->algoName))) {
qError("failed to get forecast algorithm name from %s", pSupp->algoOpt);
return TSDB_CODE_ANA_ALGO_NOT_FOUND;
}
if (taosAnalGetAlgoUrl(pSupp->algoName, ANAL_ALGO_TYPE_FORECAST, pSupp->algoUrl, sizeof(pSupp->algoUrl)) != 0) {
if (taosAnalyGetAlgoUrl(pSupp->algoName, ANALY_ALGO_TYPE_FORECAST, pSupp->algoUrl, sizeof(pSupp->algoUrl)) != 0) {
qError("failed to get forecast algorithm url from %s", pSupp->algoName);
return TSDB_CODE_ANA_ALGO_NOT_LOAD;
}
@ -539,32 +546,32 @@ static int32_t forecastParseAlgo(SForecastSupp* pSupp) {
}
static int32_t forecastCreateBuf(SForecastSupp* pSupp) {
SAnalyticBuf* pBuf = &pSupp->analBuf;
SAnalyticBuf* pBuf = &pSupp->analyBuf;
int64_t ts = 0; // taosGetTimestampMs();
pBuf->bufType = ANALYTICS_BUF_TYPE_JSON_COL;
snprintf(pBuf->fileName, sizeof(pBuf->fileName), "%s/tdengine-forecast-%" PRId64, tsTempDir, ts);
int32_t code = tsosAnalBufOpen(pBuf, 2);
int32_t code = tsosAnalyBufOpen(pBuf, 2);
if (code != 0) goto _OVER;
code = taosAnalBufWriteColMeta(pBuf, 0, TSDB_DATA_TYPE_TIMESTAMP, "ts");
code = taosAnalyBufWriteColMeta(pBuf, 0, TSDB_DATA_TYPE_TIMESTAMP, "ts");
if (code != 0) goto _OVER;
code = taosAnalBufWriteColMeta(pBuf, 1, pSupp->inputValType, "val");
code = taosAnalyBufWriteColMeta(pBuf, 1, pSupp->inputValType, "val");
if (code != 0) goto _OVER;
code = taosAnalBufWriteDataBegin(pBuf);
code = taosAnalyBufWriteDataBegin(pBuf);
if (code != 0) goto _OVER;
for (int32_t i = 0; i < 2; ++i) {
code = taosAnalBufWriteColBegin(pBuf, i);
code = taosAnalyBufWriteColBegin(pBuf, i);
if (code != 0) goto _OVER;
}
_OVER:
if (code != 0) {
(void)taosAnalBufClose(pBuf);
taosAnalBufDestroy(pBuf);
(void)taosAnalyBufClose(pBuf);
taosAnalyBufDestroy(pBuf);
}
return code;
}
@ -656,7 +663,7 @@ static void destroyForecastInfo(void* param) {
blockDataDestroy(pInfo->pRes);
pInfo->pRes = NULL;
cleanupExprSupp(&pInfo->scalarSup);
taosAnalBufDestroy(&pInfo->forecastSupp.analBuf);
taosAnalyBufDestroy(&pInfo->forecastSupp.analyBuf);
taosMemoryFreeClear(param);
}

2
source/libs/function/src/builtins.c
View File

@ -1223,7 +1223,7 @@ static int32_t translateForecast(SFunctionNode* pFunc, char* pErrBuf, int32_t le
}
SValueNode* pValue = (SValueNode*)pOption;
if (!taosAnalGetOptStr(pValue->literal, "algo", NULL, 0) != 0) {
if (!taosAnalyGetOptStr(pValue->literal, "algo", NULL, 0) != 0) {
return invaildFuncParaValueErrMsg(pErrBuf, len, "FORECAST option should include algo field");
}

8
source/libs/nodes/src/nodesMsgFuncs.c
View File

@ -425,8 +425,8 @@ static int32_t tlvDecodeValueU64(STlvDecoder* pDecoder, uint64_t* pValue) {
}
static int32_t tlvDecodeDouble(STlv* pTlv, double* pValue) {
int64_t temp = 0;
int32_t code = tlvDecodeI64(pTlv, &temp);
volatile int64_t temp = 0;
int32_t code = tlvDecodeI64(pTlv, (int64_t*)&temp);
if (TSDB_CODE_SUCCESS == code) {
*pValue = *(double*)&temp;
}
@ -434,8 +434,8 @@ static int32_t tlvDecodeDouble(STlv* pTlv, double* pValue) {
}
static int32_t tlvDecodeValueDouble(STlvDecoder* pDecoder, double* pValue) {
int64_t temp = 0;
int32_t code = tlvDecodeValueI64(pDecoder, &temp);
volatile int64_t temp = 0;
int32_t code = tlvDecodeValueI64(pDecoder, (int64_t*)&temp);
if (TSDB_CODE_SUCCESS == code) {
*pValue = *(double*)&temp;
}

2
source/libs/parser/src/parTranslater.c
View File

@ -6249,7 +6249,7 @@ static int32_t translateAnomalyWindow(STranslateContext* pCxt, SSelectStmt* pSel
SAnomalyWindowNode* pAnomaly = (SAnomalyWindowNode*)pSelect->pWindow;
int32_t code = checkAnomalyExpr(pCxt, pAnomaly->pExpr);
if (TSDB_CODE_SUCCESS == code) {
if (!taosAnalGetOptStr(pAnomaly->anomalyOpt, "algo", NULL, 0) != 0) {
if (!taosAnalyGetOptStr(pAnomaly->anomalyOpt, "algo", NULL, 0) != 0) {
return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_ANOMALY_WIN_OPT,
"ANOMALY_WINDOW option should include algo field");
}

3
tests/script/tsim/analytics/basic0.sim
View File

@ -69,6 +69,9 @@ if $data00 != 1 then
return -1
endi
print ================= too many rows error
sql_error select forecast(c6, 'algo=holtwinters, rows=1025') from ct1;
print ================= try every loaded anomaly detection algorithm
sql select count(*) from ct1 anomaly_window(c1, 'algo=iqr');
sql select count(*) from ct1 anomaly_window(c1, 'algo=ksigma');