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

Merge pull request #28778 from taosdata/main 

merge: from main to 3.0 branch
This commit is contained in:
Shengliang Guan 2024-11-15 10:14:22 +08:00 committed by GitHub
parent eb103b2382 1120383573
commit 527def388d
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
21 changed files with 479 additions and 297 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -16,7 +16,7 @@ TDengine 提供了类似于消息队列产品的数据订阅和消费接口。
**注意** **注意**
在 TDengine 连接器实现中，对于订阅查询，有以下限制。 在 TDengine 连接器实现中，对于订阅查询，有以下限制。
- 查询语句限制：订阅查询只能使用 select 语句，不支持其他类型的SQL，如 insert、update 或 delete 等。 - 查询语句限制：订阅查询只能使用 select 语句，并不支持其他类型的SQL，如订阅库，订阅超级表（非 select 方式），insert、update 或 delete 等。
- 原始始数据查询：订阅查询只能查询原始数据，而不能查询聚合或计算结果。 - 原始始数据查询：订阅查询只能查询原始数据，而不能查询聚合或计算结果。
- 时间顺序限制：订阅查询只能按照时间正序查询数据。 - 时间顺序限制：订阅查询只能按照时间正序查询数据。

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

@ -27,65 +27,65 @@ taosd 命令行参数如下
### 连接相关 ### 连接相关
|参数名称|支持版本|参数含义| |参数名称|支持版本|参数含义|
|-----------------------|-----------|-| |-----------------------|----------|-|
|firstEp | |taosd 启动时，主动连接的集群中首个 dnode 的 end point，默认值 localhost:6030| |firstEp | |taosd 启动时，主动连接的集群中首个 dnode 的 end point，默认值 localhost:6030|
|secondEp | |taosd 启动时，如果 firstEp 连接不上，尝试连接集群中第二个 dnode 的 endpoint，无默认值| |secondEp | |taosd 启动时，如果 firstEp 连接不上，尝试连接集群中第二个 dnode 的 endpoint，无默认值|
|fqdn | |taosd 监听的服务地址，默认为所在服务器上配置的第一个 hostname| |fqdn | |taosd 监听的服务地址，默认为所在服务器上配置的第一个 hostname|
|serverPort | |taosd 监听的端口，默认值 6030| |serverPort | |taosd 监听的端口，默认值 6030|
|compressMsgSize | |是否对 RPC 消息进行压缩；-1：所有消息都不压缩；0：所有消息都压缩；N (N>0)：只有大于 N 个字节的消息才压缩；默认值 -1| |compressMsgSize | |是否对 RPC 消息进行压缩；-1：所有消息都不压缩；0：所有消息都压缩；N (N>0)：只有大于 N 个字节的消息才压缩；默认值 -1|
|shellActivityTimer | |客户端向 mnode 发送心跳的时长，单位为秒，取值范围 1-120，默认值 3| |shellActivityTimer | |客户端向 mnode 发送心跳的时长，单位为秒，取值范围 1-120，默认值 3|
|numOfRpcSessions | |RPC 支持的最大连接数，取值范围 100-100000，默认值 30000| |numOfRpcSessions | |RPC 支持的最大连接数，取值范围 100-100000，默认值 30000|
|numOfRpcThreads | |RPC 线程数目，默认值为 CPU 核数的一半| |numOfRpcThreads | |RPC 线程数目，默认值为 CPU 核数的一半|
|numOfTaskQueueThreads | |dnode 处理 RPC 消息的线程数| |numOfTaskQueueThreads | |dnode 处理 RPC 消息的线程数|
|statusInterval | |dnode 与 mnode 之间的心跳间隔| |statusInterval | |dnode 与 mnode 之间的心跳间隔|
|rpcQueueMemoryAllowed | |dnode 允许的 rpc 消息占用的内存最大值，单位 bytes，取值范围 104857600-INT64_MAX，默认值 服务器内存的 1/10 | |rpcQueueMemoryAllowed | |dnode 允许的 rpc 消息占用的内存最大值，单位 bytes，取值范围 104857600-INT64_MAX，默认值 服务器内存的 1/10 |
|resolveFQDNRetryTime | |FQDN 解析失败时的重试次数| |resolveFQDNRetryTime | |FQDN 解析失败时的重试次数|
|timeToGetAvailableConn | |获得可用连接的最长等待时间，取值范围 10-50000000，单位为毫秒，默认值 500000| |timeToGetAvailableConn | |获得可用连接的最长等待时间，取值范围 10-50000000，单位为毫秒，默认值 500000|
|maxShellConns | |允许创建的最大链接数| |maxShellConns | |允许创建的最大链接数|
|maxRetryWaitTime | |重连最大超时时间| |maxRetryWaitTime | |重连最大超时时间|
|shareConnLimit |3.3.4.3 之后|内部参数，一个链接可以共享的查询数目，取值范围 1-256，默认值 10| |shareConnLimit |3.3.4.3 后|内部参数，一个链接可以共享的查询数目，取值范围 1-256，默认值 10|
|readTimeout |3.3.4.3 之后|内部参数，最小超时时间，取值范围 64-604800，单位为秒，默认值 900| |readTimeout |3.3.4.3 后|内部参数，最小超时时间，取值范围 64-604800，单位为秒，默认值 900|
### 监控相关 ### 监控相关
|参数名称|支持版本|参数含义| |参数名称|支持版本|参数含义|
|-----------------------|-----------|-| |-----------------------|----------|-|
|monitor | |是否收集监控数据并上报，0：关闭；1:打开；默认值 0| |monitor | |是否收集监控数据并上报，0：关闭；1:打开；默认值 0|
|monitorFqdn | |taosKeeper 服务所在服务器的 FQDN，默认值 无| |monitorFqdn | |taosKeeper 服务所在服务器的 FQDN，默认值 无|
|monitorPort | |taosKeeper 服务所监听的端口号，默认值 6043| |monitorPort | |taosKeeper 服务所监听的端口号，默认值 6043|
|monitorInterval | |监控数据库记录系统参数（CPU/内存）的时间间隔，单位是秒，取值范围 1-200000 ，默认值 30| |monitorInterval | |监控数据库记录系统参数（CPU/内存）的时间间隔，单位是秒，取值范围 1-200000 ，默认值 30|
|monitorMaxLogs | |缓存的待上报日志条数| |monitorMaxLogs | |缓存的待上报日志条数|
|monitorComp | |是否采用压缩方式上报监控日志时| |monitorComp | |是否采用压缩方式上报监控日志时|
|monitorLogProtocol | |是否打印监控日志| |monitorLogProtocol | |是否打印监控日志|
|monitorForceV2 | |是否使用 V2 版本协议上报| |monitorForceV2 | |是否使用 V2 版本协议上报|
|telemetryReporting | |是否上传 telemetry，0：不上传，1：上传，默认值 1| |telemetryReporting | |是否上传 telemetry，0：不上传，1：上传，默认值 1|
|telemetryServer | |telemetry 服务器地址| |telemetryServer | |telemetry 服务器地址|
|telemetryPort | |telemetry 服务器端口编号| |telemetryPort | |telemetry 服务器端口编号|
|telemetryInterval | |telemetry 上传时间间隔，单位为秒，默认 43200| |telemetryInterval | |telemetry 上传时间间隔，单位为秒，默认 43200|
|crashReporting | |是否上传 crash 信息；0：不上传，1：上传；默认值 1| |crashReporting | |是否上传 crash 信息；0：不上传，1：上传；默认值 1|
### 查询相关 ### 查询相关
|参数名称|支持版本|参数含义| |参数名称|支持版本|参数含义|
|------------------------|-----------|-| |------------------------|----------|-|
|countAlwaysReturnValue | |count/hyperloglog 函数在输入数据为空或者 NULL 的情况下是否返回值；0：返回空行，1：返回；默认值 1；该参数设置为 1 时，如果查询中含有 INTERVAL 子句或者该查询使用了 TSMA 时，且相应的组或窗口内数据为空或者 NULL，对应的组或窗口将不返回查询结果；注意此参数客户端和服务端值应保持一致| |countAlwaysReturnValue | |count/hyperloglog 函数在输入数据为空或者 NULL 的情况下是否返回值；0：返回空行，1：返回；默认值 1；该参数设置为 1 时，如果查询中含有 INTERVAL 子句或者该查询使用了 TSMA 时，且相应的组或窗口内数据为空或者 NULL，对应的组或窗口将不返回查询结果；注意此参数客户端和服务端值应保持一致|
|tagFilterCache | |是否缓存标签过滤结果| |tagFilterCache | |是否缓存标签过滤结果|
|maxNumOfDistinctRes | |允许返回的 distinct 结果最大行数，默认值 10 万，最大允许值 1 亿| |maxNumOfDistinctRes | |允许返回的 distinct 结果最大行数，默认值 10 万，最大允许值 1 亿|
|queryBufferSize | |暂不生效| |queryBufferSize | |暂不生效|
|queryRspPolicy | |查询响应策略| |queryRspPolicy | |查询响应策略|
|filterScalarMode | |强制使用标量过滤模式，0：关闭；1：开启，默认值 0| |filterScalarMode | |强制使用标量过滤模式，0：关闭；1：开启，默认值 0|
|queryPlannerTrace | |内部参数，查询计划是否输出详细日志| |queryPlannerTrace | |内部参数，查询计划是否输出详细日志|
|queryNodeChunkSize | |内部参数，查询计划的块大小| |queryNodeChunkSize | |内部参数，查询计划的块大小|
|queryUseNodeAllocator | |内部参数，查询计划的分配方法| |queryUseNodeAllocator | |内部参数，查询计划的分配方法|
|queryMaxConcurrentTables| |内部参数，查询计划的并发数目| |queryMaxConcurrentTables| |内部参数，查询计划的并发数目|
|queryRsmaTolerance | |内部参数，用于判定查询哪一级 rsma 数据时的容忍时间，单位为毫秒| |queryRsmaTolerance | |内部参数，用于判定查询哪一级 rsma 数据时的容忍时间，单位为毫秒|
|enableQueryHb | |内部参数，是否发送查询心跳消息| |enableQueryHb | |内部参数，是否发送查询心跳消息|
|pqSortMemThreshold | |内部参数，排序使用的内存阈值| |pqSortMemThreshold | |内部参数，排序使用的内存阈值|
### 区域相关 ### 区域相关
|参数名称|支持版本|参数含义| |参数名称|支持版本|参数含义|
|-----------------|-----------|-| |-----------------|----------|-|
|timezone | |时区；缺省从系统中动态获取当前的时区设置| |timezone | |时区；缺省从系统中动态获取当前的时区设置|
|locale | |系统区位信息及编码格式，缺省从系统中获取| |locale | |系统区位信息及编码格式，缺省从系统中获取|
|charset | |字符集编码，缺省从系统中获取| |charset | |字符集编码，缺省从系统中获取|
:::info :::info
1. 为应对多时区的数据写入和查询问题，TDengine 采用 Unix 时间戳(Unix Timestamp)来记录和存储时间戳。Unix 时间戳的特点决定了任一时刻不论在任何时区，产生的时间戳均一致。需要注意的是，Unix 时间戳是在客户端完成转换和记录。为了确保客户端其他形式的时间转换为正确的 Unix 时间戳，需要设置正确的时区。 1. 为应对多时区的数据写入和查询问题，TDengine 采用 Unix 时间戳(Unix Timestamp)来记录和存储时间戳。Unix 时间戳的特点决定了任一时刻不论在任何时区，产生的时间戳均一致。需要注意的是，Unix 时间戳是在客户端完成转换和记录。为了确保客户端其他形式的时间转换为正确的 Unix 时间戳，需要设置正确的时区。
@ -164,147 +164,147 @@ charset 的有效值是 UTF-8。
### 存储相关 ### 存储相关
|参数名称|支持版本|参数含义| |参数名称|支持版本|参数含义|
|--------------------|-----------|-| |--------------------|----------|-|
|dataDir | |数据文件目录，所有的数据文件都将写入该目录，默认值 /var/lib/taos| |dataDir | |数据文件目录，所有的数据文件都将写入该目录，默认值 /var/lib/taos|
|tempDir | |指定所有系统运行过程中的临时文件生成的目录，默认值 /tmp| |tempDir | |指定所有系统运行过程中的临时文件生成的目录，默认值 /tmp|
|minimalDataDirGB | |dataDir 指定的时序数据存储目录所需要保留的最小空间，单位 GB，默认值 2| |minimalDataDirGB | |dataDir 指定的时序数据存储目录所需要保留的最小空间，单位 GB，默认值 2|
|minimalTmpDirGB | |tempDir 所指定的临时文件目录所需要保留的最小空间，单位 GB，默认值 1| |minimalTmpDirGB | |tempDir 所指定的临时文件目录所需要保留的最小空间，单位 GB，默认值 1|
|minDiskFreeSize |3.1.1.0 之后|当某块磁盘上的可用空间小于等于这个阈值时，该磁盘将不再被选择用于生成新的数据文件，单位为字节，取值范围 52428800-1073741824，默认值为 52428800；企业版参数| |minDiskFreeSize |3.1.1.0 后|当某块磁盘上的可用空间小于等于这个阈值时，该磁盘将不再被选择用于生成新的数据文件，单位为字节，取值范围 52428800-1073741824，默认值为 52428800；企业版参数|
|s3MigrateIntervalSec|3.3.4.3 之后|本地数据文件自动上传 S3 的触发周期，单位为秒。最小值：600；最大值：100000。默认值 3600；企业版参数| |s3MigrateIntervalSec|3.3.4.3 后|本地数据文件自动上传 S3 的触发周期，单位为秒。最小值：600；最大值：100000。默认值 3600；企业版参数|
|s3MigrateEnabled |3.3.4.3 之后|是否自动进行 S3 迁移，默认值为 0，表示关闭自动 S3 迁移，可配置为 1；企业版参数| |s3MigrateEnabled |3.3.4.3 后|是否自动进行 S3 迁移，默认值为 0，表示关闭自动 S3 迁移，可配置为 1；企业版参数|
|s3Accesskey |3.3.4.3 之后|冒号分隔的用户 SecretId:SecretKey，例如 AKIDsQmwsfKxTo2A6nGVXZN0UlofKn6JRRSJ:lIdoy99ygEacU7iHfogaN2Xq0yumSm1E；企业版参数| |s3Accesskey |3.3.4.3 后|冒号分隔的用户 SecretId:SecretKey，例如 AKIDsQmwsfKxTo2A6nGVXZN0UlofKn6JRRSJ:lIdoy99ygEacU7iHfogaN2Xq0yumSm1E；企业版参数|
|s3Endpoint |3.3.4.3 之后|用户所在地域的 COS 服务域名，支持 http 和 https，bucket 的区域需要与 endpoint 保持一致，否则无法访问；企业版参数| |s3Endpoint |3.3.4.3 后|用户所在地域的 COS 服务域名，支持 http 和 https，bucket 的区域需要与 endpoint 保持一致，否则无法访问；企业版参数|
|s3BucketName |3.3.4.3 之后|存储桶名称，减号后面是用户注册 COS 服务的 AppId，其中 AppId 是 COS 特有，AWS 和阿里云都没有，配置时需要作为 bucket name 的一部分，使用减号分隔；参数值均为字符串类型，但不需要引号；例如 test0711-1309024725；企业版参数| |s3BucketName |3.3.4.3 后|存储桶名称，减号后面是用户注册 COS 服务的 AppId，其中 AppId 是 COS 特有，AWS 和阿里云都没有，配置时需要作为 bucket name 的一部分，使用减号分隔；参数值均为字符串类型，但不需要引号；例如 test0711-1309024725；企业版参数|
|s3PageCacheSize |3.3.4.3 之后|S3 page cache 缓存页数目，取值范围 4-1048576，单位为页，默认值 4096；企业版参数| |s3PageCacheSize |3.3.4.3 后|S3 page cache 缓存页数目，取值范围 4-1048576，单位为页，默认值 4096；企业版参数|
|s3UploadDelaySec |3.3.4.3 之后|data 文件持续多长时间不再变动后上传至 S3，取值范围 1-2592000 (30天），单位为秒，默认值 60；企业版参数| |s3UploadDelaySec |3.3.4.3 后|data 文件持续多长时间不再变动后上传至 S3，取值范围 1-2592000 (30天），单位为秒，默认值 60；企业版参数|
|cacheLazyLoadThreshold | |内部参数，缓存的装载策略| |cacheLazyLoadThreshold| |内部参数，缓存的装载策略|
### 集群相关 ### 集群相关
|参数名称|支持版本|参数含义| |参数名称|支持版本|参数含义|
|--------------------------|-----------|-| |--------------------------|----------|-|
|supportVnodes | |dnode 支持的最大 vnode 数目，取值范围 0-4096，默认值 CPU 核数的 2 倍 + 5| |supportVnodes | |dnode 支持的最大 vnode 数目，取值范围 0-4096，默认值 CPU 核数的 2 倍 + 5|
|numOfCommitThreads | |落盘线程的最大数量，取值范围 0-1024，默认值为 4| |numOfCommitThreads | |落盘线程的最大数量，取值范围 0-1024，默认值为 4|
|numOfMnodeReadThreads | |mnode 的 Read 线程数目，取值范围 0-1024，默认值为 CPU 核数的四分之一（不超过 4）| |numOfMnodeReadThreads | |mnode 的 Read 线程数目，取值范围 0-1024，默认值为 CPU 核数的四分之一（不超过 4）|
|numOfVnodeQueryThreads | |vnode 的 Query 线程数目，取值范围 0-1024，默认值为 CPU 核数的两倍（不超过 16）| |numOfVnodeQueryThreads | |vnode 的 Query 线程数目，取值范围 0-1024，默认值为 CPU 核数的两倍（不超过 16）|
|numOfVnodeFetchThreads | |vnode 的 Fetch 线程数目，取值范围 0-1024，默认值为 CPU 核数的四分之一（不超过 4）| |numOfVnodeFetchThreads | |vnode 的 Fetch 线程数目，取值范围 0-1024，默认值为 CPU 核数的四分之一（不超过 4）|
|numOfVnodeRsmaThreads | |vnode 的 Rsma 线程数目，取值范围 0-1024，默认值为 CPU 核数的四分之一（不超过 4）| |numOfVnodeRsmaThreads | |vnode 的 Rsma 线程数目，取值范围 0-1024，默认值为 CPU 核数的四分之一（不超过 4）|
|numOfQnodeQueryThreads | |qnode 的 Query 线程数目，取值范围 0-1024，默认值为 CPU 核数的两倍（不超过 16）| |numOfQnodeQueryThreads | |qnode 的 Query 线程数目，取值范围 0-1024，默认值为 CPU 核数的两倍（不超过 16）|
|numOfSnodeSharedThreads | |snode 的共享线程数目，取值范围 0-1024，默认值为 CPU 核数的四分之一（不小于 2，不超过 4）| |numOfSnodeSharedThreads | |snode 的共享线程数目，取值范围 0-1024，默认值为 CPU 核数的四分之一（不小于 2，不超过 4）|
|numOfSnodeUniqueThreads | |snode 的独占线程数目，取值范围 0-1024，默认值为 CPU 核数的四分之一（不小于 2，不超过 4）| |numOfSnodeUniqueThreads | |snode 的独占线程数目，取值范围 0-1024，默认值为 CPU 核数的四分之一（不小于 2，不超过 4）|
|ratioOfVnodeStreamThreads | |流计算使用 vnode 线程的比例，取值范围 0.01-4，默认值 4| |ratioOfVnodeStreamThreads | |流计算使用 vnode 线程的比例，取值范围 0.01-4，默认值 4|
|ttlUnit | |ttl 参数的单位，取值范围 1-31572500，单位为秒，默认值 86400| |ttlUnit | |ttl 参数的单位，取值范围 1-31572500，单位为秒，默认值 86400|
|ttlPushInterval | |ttl 检测超时频率，取值范围 1-100000，单位为秒，默认值 10| |ttlPushInterval | |ttl 检测超时频率，取值范围 1-100000，单位为秒，默认值 10|
|ttlChangeOnWrite | |ttl 到期时间是否伴随表的修改操作改变；0：不改变，1：改变；默认值为 0| |ttlChangeOnWrite | |ttl 到期时间是否伴随表的修改操作改变；0：不改变，1：改变；默认值为 0|
|ttlBatchDropNum | |ttl 一批删除子表的数目，最小值为 0，默认值 10000| |ttlBatchDropNum | |ttl 一批删除子表的数目，最小值为 0，默认值 10000|
|retentionSpeedLimitMB | |数据在不同级别硬盘上迁移时的速度限制，取值范围 0-1024，单位 MB，默认值 0，表示不限制| |retentionSpeedLimitMB | |数据在不同级别硬盘上迁移时的速度限制，取值范围 0-1024，单位 MB，默认值 0，表示不限制|
|maxTsmaNum | |集群内可创建的TSMA个数；取值范围 0-3；默认值 3| |maxTsmaNum | |集群内可创建的TSMA个数；取值范围 0-3；默认值 3|
|tmqMaxTopicNum | |订阅最多可建立的 topic 数量；取值范围 1-10000；默认值为 20| |tmqMaxTopicNum | |订阅最多可建立的 topic 数量；取值范围 1-10000；默认值为 20|
|tmqRowSize | |订阅数据块的最大记录条数，取值范围 1-1000000，默认值 4096| |tmqRowSize | |订阅数据块的最大记录条数，取值范围 1-1000000，默认值 4096|
|audit | |审计功能开关；企业版参数| |audit | |审计功能开关；企业版参数|
|auditInterval | |审计数据上报的时间间隔；企业版参数| |auditInterval | |审计数据上报的时间间隔；企业版参数|
|auditCreateTable | |是否针对创建子表开启申计功能；企业版参数| |auditCreateTable | |是否针对创建子表开启申计功能；企业版参数|
|encryptAlgorithm | |数据加密算法；企业版参数| |encryptAlgorithm | |数据加密算法；企业版参数|
|encryptScope | |加密范围；企业版参数| |encryptScope | |加密范围；企业版参数|
|enableWhiteList | |白名单功能开关；企业版参数| |enableWhiteList | |白名单功能开关；企业版参数|
|syncLogBufferMemoryAllowed| |一个 dnode 允许的 sync 日志缓存消息占用的内存最大值，单位 bytes，取值范围 104857600-INT64_MAX，默认值 服务器内存的 1/10，3.1.3.2/3.3.2.13 版本开始生效 | |syncLogBufferMemoryAllowed| |一个 dnode 允许的 sync 日志缓存消息占用的内存最大值，单位 bytes，取值范围 104857600-INT64_MAX，默认值 服务器内存的 1/10，3.1.3.2/3.3.2.13 版本开始生效 |
|syncElectInterval | |内部参数，用于同步模块调试| |syncElectInterval | |内部参数，用于同步模块调试|
|syncHeartbeatInterval | |内部参数，用于同步模块调试| |syncHeartbeatInterval | |内部参数，用于同步模块调试|
|syncHeartbeatTimeout | |内部参数，用于同步模块调试| |syncHeartbeatTimeout | |内部参数，用于同步模块调试|
|syncSnapReplMaxWaitN | |内部参数，用于同步模块调试| |syncSnapReplMaxWaitN | |内部参数，用于同步模块调试|
|syncSnapReplMaxWaitN | |内部参数，用于同步模块调试| |syncSnapReplMaxWaitN | |内部参数，用于同步模块调试|
|arbHeartBeatIntervalSec | |内部参数，用于同步模块调试| |arbHeartBeatIntervalSec | |内部参数，用于同步模块调试|
|arbCheckSyncIntervalSec | |内部参数，用于同步模块调试| |arbCheckSyncIntervalSec | |内部参数，用于同步模块调试|
|arbSetAssignedTimeoutSec | |内部参数，用于同步模块调试| |arbSetAssignedTimeoutSec | |内部参数，用于同步模块调试|
|mndSdbWriteDelta | |内部参数，用于 mnode 模块调试| |mndSdbWriteDelta | |内部参数，用于 mnode 模块调试|
|mndLogRetention | |内部参数，用于 mnode 模块调试| |mndLogRetention | |内部参数，用于 mnode 模块调试|
|skipGrant | |内部参数，用于授权检查| |skipGrant | |内部参数，用于授权检查|
|trimVDbIntervalSec | |内部参数，用于删除过期数据| |trimVDbIntervalSec | |内部参数，用于删除过期数据|
|ttlFlushThreshold | |内部参数，ttl 定时器的频率| |ttlFlushThreshold | |内部参数，ttl 定时器的频率|
|compactPullupInterval | |内部参数，数据重整定时器的频率| |compactPullupInterval | |内部参数，数据重整定时器的频率|
|walFsyncDataSizeLimit | |内部参数，WAL 进行 FSYNC 的阈值| |walFsyncDataSizeLimit | |内部参数，WAL 进行 FSYNC 的阈值|
|transPullupInterval | |内部参数，mnode 执行事务的重试间隔| |transPullupInterval | |内部参数，mnode 执行事务的重试间隔|
|mqRebalanceInterval | |内部参数，消费者再平衡的时间间隔| |mqRebalanceInterval | |内部参数，消费者再平衡的时间间隔|
|uptimeInterval | |内部参数，用于记录系统启动时间| |uptimeInterval | |内部参数，用于记录系统启动时间|
|timeseriesThreshold | |内部参数，用于统计用量| |timeseriesThreshold | |内部参数，用于统计用量|
|udf | |是否启动 UDF 服务；0：不启动，1：启动；默认值为 0 | |udf | |是否启动 UDF 服务；0：不启动，1：启动；默认值为 0 |
|udfdResFuncs | |内部参数，用于 UDF 结果集设置| |udfdResFuncs | |内部参数，用于 UDF 结果集设置|
|udfdLdLibPath | |内部参数，表示 UDF 装载的库路径| |udfdLdLibPath | |内部参数，表示 UDF 装载的库路径|
### 流计算参数 ### 流计算参数
|参数名称|支持版本|参数含义| |参数名称|支持版本|参数含义|
|-----------------------|-----------|-| |-----------------------|----------|-|
|disableStream | |流计算的启动开关| |disableStream | |流计算的启动开关|
|streamBufferSize | |控制内存中窗口状态缓存的大小，默认值为 128MB| |streamBufferSize | |控制内存中窗口状态缓存的大小，默认值为 128MB|
|streamAggCnt | |内部参数，并发进行聚合计算的数目| |streamAggCnt | |内部参数，并发进行聚合计算的数目|
|checkpointInterval | |内部参数，checkponit 同步间隔| |checkpointInterval | |内部参数，checkponit 同步间隔|
|concurrentCheckpoint | |内部参数，是否并发检查 checkpoint| |concurrentCheckpoint | |内部参数，是否并发检查 checkpoint|
|maxStreamBackendCache | |内部参数，流计算使用的最大缓存| |maxStreamBackendCache | |内部参数，流计算使用的最大缓存|
|streamSinkDataRate | |内部参数，用于控制流计算结果的写入速度| |streamSinkDataRate | |内部参数，用于控制流计算结果的写入速度|
### 日志相关 ### 日志相关
|参数名称|支持版本|参数含义| |参数名称|支持版本|参数含义|
|----------------|-----------|-| |----------------|----------|-|
|logDir | |日志文件目录，运行日志将写入该目录，默认值 /var/log/taos| |logDir | |日志文件目录，运行日志将写入该目录，默认值 /var/log/taos|
|minimalLogDirGB | |日志文件夹所在磁盘可用空间大小小于该值时，停止写日志，单位 GB，默认值 1| |minimalLogDirGB | |日志文件夹所在磁盘可用空间大小小于该值时，停止写日志，单位 GB，默认值 1|
|numOfLogLines | |单个日志文件允许的最大行数，默认值 10,000,000| |numOfLogLines | |单个日志文件允许的最大行数，默认值 10,000,000|
|asyncLog | |日志写入模式，0：同步，1：异步，默认值 1| |asyncLog | |日志写入模式，0：同步，1：异步，默认值 1|
|logKeepDays | |日志文件的最长保存时间，单位：天，默认值 0，意味着无限保存，日志文件不会被重命名，也不会有新的日志文件滚动产生，但日志文件的内容有可能会不断滚动，取决于日志文件大小的设置；当设置为大于 0 的值时，当日志文件大小达到设置的上限时会被重命名为 taosdlog.yyy，其中 yyy 为日志文件最后修改的时间戳，并滚动产生新的日志文件| |logKeepDays | |日志文件的最长保存时间，单位：天，默认值 0，意味着无限保存，日志文件不会被重命名，也不会有新的日志文件滚动产生，但日志文件的内容有可能会不断滚动，取决于日志文件大小的设置；当设置为大于 0 的值时，当日志文件大小达到设置的上限时会被重命名为 taosdlog.yyy，其中 yyy 为日志文件最后修改的时间戳，并滚动产生新的日志文件|
|slowLogThreshold|3.3.3.0 之后|慢查询门限值，大于等于门限值认为是慢查询，单位秒，默认值 3 | |slowLogThreshold|3.3.3.0 后|慢查询门限值，大于等于门限值认为是慢查询，单位秒，默认值 3 |
|slowLogMaxLen |3.3.3.0 之后|慢查询日志最大长度，取值范围 1-16384，默认值 4096| |slowLogMaxLen |3.3.3.0 后|慢查询日志最大长度，取值范围 1-16384，默认值 4096|
|slowLogScope |3.3.3.0 之后|慢查询记录类型，取值范围 ALL/QUERY/INSERT/OTHERS/NONE，默认值 QUERY| |slowLogScope |3.3.3.0 后|慢查询记录类型，取值范围 ALL/QUERY/INSERT/OTHERS/NONE，默认值 QUERY|
|slowLogExceptDb |3.3.3.0 之后|指定的数据库不上报慢查询，仅支持配置换一个数据库| |slowLogExceptDb |3.3.3.0 后|指定的数据库不上报慢查询，仅支持配置换一个数据库|
|debugFlag | |运行日志开关，131（输出错误和警告日志），135（输出错误、警告和调试日志），143（输出错误、警告、调试和跟踪日志）；默认值 131 或 135 （取决于不同模块）| |debugFlag | |运行日志开关，131（输出错误和警告日志），135（输出错误、警告和调试日志），143（输出错误、警告、调试和跟踪日志）；默认值 131 或 135 （取决于不同模块）|
|tmrDebugFlag | |定时器模块的日志开关，取值范围同上| |tmrDebugFlag | |定时器模块的日志开关，取值范围同上|
|uDebugFlag | |共用功能模块的日志开关，取值范围同上| |uDebugFlag | |共用功能模块的日志开关，取值范围同上|
|rpcDebugFlag | |rpc 模块的日志开关，取值范围同上| |rpcDebugFlag | |rpc 模块的日志开关，取值范围同上|
|qDebugFlag | |query 模块的日志开关，取值范围同上| |qDebugFlag | |query 模块的日志开关，取值范围同上|
|dDebugFlag | |dnode 模块的日志开关，取值范围同上| |dDebugFlag | |dnode 模块的日志开关，取值范围同上|
|vDebugFlag | |vnode 模块的日志开关，取值范围同上| |vDebugFlag | |vnode 模块的日志开关，取值范围同上|
|mDebugFlag | |mnode 模块的日志开关，取值范围同上| |mDebugFlag | |mnode 模块的日志开关，取值范围同上|
|azDebugFlag |3.3.4.3 之后|S3 模块的日志开关，取值范围同上| |azDebugFlag |3.3.4.3 后|S3 模块的日志开关，取值范围同上|
|sDebugFlag | |sync 模块的日志开关，取值范围同上| |sDebugFlag | |sync 模块的日志开关，取值范围同上|
|tsdbDebugFlag | |tsdb 模块的日志开关，取值范围同上| |tsdbDebugFlag | |tsdb 模块的日志开关，取值范围同上|
|tqDebugFlag | |tq 模块的日志开关，取值范围同上| |tqDebugFlag | |tq 模块的日志开关，取值范围同上|
|fsDebugFlag | |fs 模块的日志开关，取值范围同上| |fsDebugFlag | |fs 模块的日志开关，取值范围同上|
|udfDebugFlag | |udf 模块的日志开关，取值范围同上| |udfDebugFlag | |udf 模块的日志开关，取值范围同上|
|smaDebugFlag | |sma 模块的日志开关，取值范围同上| |smaDebugFlag | |sma 模块的日志开关，取值范围同上|
|idxDebugFlag | |index 模块的日志开关，取值范围同上| |idxDebugFlag | |index 模块的日志开关，取值范围同上|
|tdbDebugFlag | |tdb 模块的日志开关，取值范围同上| |tdbDebugFlag | |tdb 模块的日志开关，取值范围同上|
|metaDebugFlag | |meta 模块的日志开关，取值范围同上| |metaDebugFlag | |meta 模块的日志开关，取值范围同上|
|stDebugFlag | |stream 模块的日志开关，取值范围同上| |stDebugFlag | |stream 模块的日志开关，取值范围同上|
|sndDebugFlag | |snode 模块的日志开关，取值范围同上| |sndDebugFlag | |snode 模块的日志开关，取值范围同上|
### 调试相关 ### 调试相关
|参数名称|支持版本|参数含义| |参数名称|支持版本|参数含义|
|--------------------|-----------|-| |--------------------|----------|-|
|enableCoreFile | |crash 时是否生成 core 文件，0：不生成，1：生成；默认值 1| |enableCoreFile | |crash 时是否生成 core 文件，0：不生成，1：生成；默认值 1|
|configDir | |配置文件所在目录| |configDir | |配置文件所在目录|
|scriptDir | |内部测试工具的脚本目录| |scriptDir | |内部测试工具的脚本目录|
|assert | |断言控制开关，默认值 0| |assert | |断言控制开关，默认值 0|
|randErrorChance | |内部参数，用于随机失败测试| |randErrorChance | |内部参数，用于随机失败测试|
|randErrorDivisor | |内部参数，用于随机失败测试| |randErrorDivisor | |内部参数，用于随机失败测试|
|randErrorScope | |内部参数，用于随机失败测试| |randErrorScope | |内部参数，用于随机失败测试|
|safetyCheckLevel | |内部参数，用于随机失败测试| |safetyCheckLevel | |内部参数，用于随机失败测试|
|experimental | |内部参数，用于一些实验特性| |experimental | |内部参数，用于一些实验特性|
|simdEnable |3.3.4.3 之后|内部参数，用于测试 SIMD 加速| |simdEnable |3.3.4.3 后|内部参数，用于测试 SIMD 加速|
|AVX512Enable |3.3.4.3 之后|内部参数，用于测试 AVX512 加速| |AVX512Enable |3.3.4.3 后|内部参数，用于测试 AVX512 加速|
|rsyncPort | |内部参数，用于调试流计算| |rsyncPort | |内部参数，用于调试流计算|
|snodeAddress | |内部参数，用于调试流计算| |snodeAddress | |内部参数，用于调试流计算|
|checkpointBackupDir | |内部参数，用于恢复 snode 数据| |checkpointBackupDir | |内部参数，用于恢复 snode 数据|
|enableAuditDelete | |内部参数，用于测试审计功能| |enableAuditDelete | |内部参数，用于测试审计功能|
|slowLogThresholdTest| |内部参数，用于测试慢日志| |slowLogThresholdTest| |内部参数，用于测试慢日志|
### 压缩参数 ### 压缩参数
|参数名称|支持版本|参数含义| |参数名称|支持版本|参数含义|
|------------|-----------|-| |------------|----------|-|
|fPrecision | |设置 float 类型浮点数压缩精度 ，取值范围 0.1 ~ 0.00000001 ，默认值 0.00000001 , 小于此值的浮点数尾数部分将被截断| |fPrecision | |设置 float 类型浮点数压缩精度 ，取值范围 0.1 ~ 0.00000001 ，默认值 0.00000001 , 小于此值的浮点数尾数部分将被截断|
|dPrecision | |设置 double 类型浮点数压缩精度 , 取值范围 0.1 ~ 0.0000000000000001 ， 默认值 0.0000000000000001 ， 小于此值的浮点数尾数部分将被截取| |dPrecision | |设置 double 类型浮点数压缩精度 , 取值范围 0.1 ~ 0.0000000000000001 ， 默认值 0.0000000000000001 ， 小于此值的浮点数尾数部分将被截取|
|lossyColumn |3.3.0.0 之前|对 float 和/或 double 类型启用 TSZ 有损压缩；取值范围 float/double/none；默认值 none，表示关闭无损压缩| |lossyColumn |3.3.0.0 前|对 float 和/或 double 类型启用 TSZ 有损压缩；取值范围 float/double/none；默认值 none，表示关闭无损压缩|
|ifAdtFse | |在启用 TSZ 有损压缩时，使用 FSE 算法替换 HUFFMAN 算法，FSE 算法压缩速度更快，但解压稍慢，追求压缩速度可选用此算法；0：关闭，1：打开；默认值为 0| |ifAdtFse | |在启用 TSZ 有损压缩时，使用 FSE 算法替换 HUFFMAN 算法，FSE 算法压缩速度更快，但解压稍慢，追求压缩速度可选用此算法；0：关闭，1：打开；默认值为 0|
|maxRange | |内部参数，用于有损压缩设置| |maxRange | |内部参数，用于有损压缩设置|
|curRange | |内部参数，用于有损压缩设置| |curRange | |内部参数，用于有损压缩设置|
|compressor | |内部参数，用于有损压缩设置| |compressor | |内部参数，用于有损压缩设置|
**补充说明** **补充说明**
1. 在 3.2.0.0 ~ 3.3.0.0（不包含）版本生效，启用该参数后不能回退到升级前的版本 1. 在 3.2.0.0 ~ 3.3.0.0（不包含）版本生效，启用该参数后不能回退到升级前的版本

141
docs/zh/14-reference/01-components/02-taosc.md
View File

@ -10,99 +10,98 @@ TDengine 客户端驱动提供了应用编程所需要的全部 API，并且在
### 连接相关 ### 连接相关
|参数名称|支持版本|参数含义| |参数名称|支持版本|参数含义|
|----------------------|-----------|-| |----------------------|----------|-|
|firstEp | |启动时，主动连接的集群中首个 dnode 的 endpoint，缺省值：hostname:6030，若无法获取该服务器的 hostname，则赋值为 localhost| |firstEp | |启动时，主动连接的集群中首个 dnode 的 endpoint，缺省值：hostname:6030，若无法获取该服务器的 hostname，则赋值为 localhost|
|secondEp | |启动时，如果 firstEp 连接不上，尝试连接集群中第二个 dnode 的 endpoint，没有缺省值| |secondEp | |启动时，如果 firstEp 连接不上，尝试连接集群中第二个 dnode 的 endpoint，没有缺省值|
|compressMsgSize | |是否对 RPC 消息进行压缩；-1：所有消息都不压缩；0：所有消息都压缩；N (N>0)：只有大于 N 个字节的消息才压缩；缺省值 -1| |compressMsgSize | |是否对 RPC 消息进行压缩；-1：所有消息都不压缩；0：所有消息都压缩；N (N>0)：只有大于 N 个字节的消息才压缩；缺省值 -1|
|shellActivityTimer | |客户端向 mnode 发送心跳的时长，单位为秒，取值范围 1-120，默认值 3| |shellActivityTimer | |客户端向 mnode 发送心跳的时长，单位为秒，取值范围 1-120，默认值 3|
|numOfRpcSessions | |RPC 支持的最大连接数，取值范围 100-100000，缺省值 30000| |numOfRpcSessions | |RPC 支持的最大连接数，取值范围 100-100000，缺省值 30000|
|numOfRpcThreads | |RPC 线程数目，默认值为 CPU 核数的一半| |numOfRpcThreads | |RPC 线程数目，默认值为 CPU 核数的一半|
|timeToGetAvailableConn| |获得可用连接的最长等待时间，取值范围 10-50000000，单位为毫秒，缺省值 500000| |timeToGetAvailableConn| |获得可用连接的最长等待时间，取值范围 10-50000000，单位为毫秒，缺省值 500000|
|useAdapter | |内部参数，是否使用 taosadapter，影响 CSV 文件导入| |useAdapter | |内部参数，是否使用 taosadapter，影响 CSV 文件导入|
|shareConnLimit |3.3.4.3 之后|内部参数，一个链接可以共享的查询数目，取值范围 1-256，默认值 10| |shareConnLimit |3.3.4.3 后|内部参数，一个链接可以共享的查询数目，取值范围 1-256，默认值 10|
|readTimeout |3.3.4.3 之后|内部参数，最小超时时间，取值范围 64-604800，单位为秒，默认值 900| |readTimeout |3.3.4.3 后|内部参数，最小超时时间，取值范围 64-604800，单位为秒，默认值 900|
### 查询相关 ### 查询相关
|参数名称|支持版本|参数含义| |参数名称|支持版本|参数含义|
|---------------------------------|-----------|-| |---------------------------------|---------|-|
|countAlwaysReturnValue | |count/hyperloglog 函数在输入数据为空或者 NULL 的情况下是否返回值；0：返回空行，1：返回；默认值 1；该参数设置为 1 时，如果查询中含有 INTERVAL 子句或者该查询使用了 TSMA 时，且相应的组或窗口内数据为空或者 NULL，对应的组或窗口将不返回查询结果；注意此参数客户端和服务端值应保持一致| |countAlwaysReturnValue | |count/hyperloglog 函数在输入数据为空或者 NULL 的情况下是否返回值；0：返回空行，1：返回；默认值 1；该参数设置为 1 时，如果查询中含有 INTERVAL 子句或者该查询使用了 TSMA 时，且相应的组或窗口内数据为空或者 NULL，对应的组或窗口将不返回查询结果；注意此参数客户端和服务端值应保持一致|
|keepColumnName | |Last、First、LastRow 函数查询且未指定别名时，自动设置别名为列名（不含函数名），因此 order by 子句如果引用了该列名将自动引用该列对应的函数；1：表示自动设置别名为列名(不包含函数名)，0：表示不自动设置别名；缺省值：0| |keepColumnName | |Last、First、LastRow 函数查询且未指定别名时，自动设置别名为列名（不含函数名），因此 order by 子句如果引用了该列名将自动引用该列对应的函数；1：表示自动设置别名为列名(不包含函数名)，0：表示不自动设置别名；缺省值：0|
|multiResultFunctionStarReturnTags|3.3.3.0 以后|查询超级表时，last(\*)/last_row(\*)/first(\*) 是否返回标签列；查询普通表、子表时，不受该参数影响；0：不返回标签列，1：返回标签列；缺省值：0；该参数设置为 0 时，last(\*)/last_row(\*)/first(\*) 只返回超级表的普通列；为 1 时，返回超级表的普通列和标签列| |multiResultFunctionStarReturnTags|3.3.3.0 后|查询超级表时，last(\*)/last_row(\*)/first(\*) 是否返回标签列；查询普通表、子表时，不受该参数影响；0：不返回标签列，1：返回标签列；缺省值：0；该参数设置为 0 时，last(\*)/last_row(\*)/first(\*) 只返回超级表的普通列；为 1 时，返回超级表的普通列和标签列|
| |metaCacheMaxSize | |指定单个客户端元数据缓存大小的最大值，单位 MB；缺省值 -1，表示无限制|
| |指定单个客户端元数据缓存大小的最大值，单位 MB；缺省值 -1，表示无限制| |maxTsmaCalcDelay | |查询时客户端可允许的 tsma 计算延迟，若 tsma 的计算延迟大于配置值，则该 TSMA 将不会被使用；取值范围 600s - 86400s，即 10 分钟 - 1 小时；缺省值：600 秒|
|maxTsmaCalcDelay | |查询时客户端可允许的 tsma 计算延迟，若 tsma 的计算延迟大于配置值，则该 TSMA 将不会被使用；取值范围 600s - 86400s，即 10 分钟 - 1 小时；缺省值：600 秒| |tsmaDataDeleteMark | |TSMA 计算的历史数据中间结果保存时间，单位为毫秒；取值范围 >= 3600000，即大于等于1h；缺省值：86400000，即 1d |
|tsmaDataDeleteMark | |TSMA 计算的历史数据中间结果保存时间，单位为毫秒；取值范围 >= 3600000，即大于等于1h；缺省值：86400000，即 1d | |queryPolicy | |查询语句的执行策略，1：只使用 vnode，不使用 qnode；2：没有扫描算子的子任务在 qnode 执行，带扫描算子的子任务在 vnode 执行；3：vnode 只运行扫描算子，其余算子均在 qnode 执行；缺省值：1|
|queryPolicy | |查询语句的执行策略，1：只使用 vnode，不使用 qnode；2：没有扫描算子的子任务在 qnode 执行，带扫描算子的子任务在 vnode 执行；3：vnode 只运行扫描算子，其余算子均在 qnode 执行；缺省值：1| |queryTableNotExistAsEmpty | |查询表不存在时是否返回空结果集；false：返回错误；true：返回空结果集；缺省值 false|
|queryTableNotExistAsEmpty | |查询表不存在时是否返回空结果集；false：返回错误；true：返回空结果集；缺省值 false| |querySmaOptimize | |sma index 的优化策略，0：表示不使用 sma index，永远从原始数据进行查询；1：表示使用 sma index，对符合的语句，直接从预计算的结果进行查询；缺省值：0|
|querySmaOptimize | |sma index 的优化策略，0：表示不使用 sma index，永远从原始数据进行查询；1：表示使用 sma index，对符合的语句，直接从预计算的结果进行查询；缺省值：0| |queryPlannerTrace | |内部参数，查询计划是否输出详细日志|
|queryPlannerTrace | |内部参数，查询计划是否输出详细日志| |queryNodeChunkSize | |内部参数，查询计划的块大小|
|queryNodeChunkSize | |内部参数，查询计划的块大小| |queryUseNodeAllocator | |内部参数，查询计划的分配方法|
|queryUseNodeAllocator | |内部参数，查询计划的分配方法| |queryMaxConcurrentTables | |内部参数，查询计划的并发数目|
|queryMaxConcurrentTables | |内部参数，查询计划的并发数目| |enableQueryHb | |内部参数，是否发送查询心跳消息|
|enableQueryHb | |内部参数，是否发送查询心跳消息| |minSlidingTime | |内部参数，sliding 的最小允许值|
|minSlidingTime | |内部参数，sliding 的最小允许值| |minIntervalTime | |内部参数，interval 的最小允许值|
|minIntervalTime | |内部参数，interval 的最小允许值|
### 写入相关 ### 写入相关
|参数名称|支持版本|参数含义| |参数名称|支持版本|参数含义|
|------------------------------|-----------|-| |------------------------------|----------|-|
|smlChildTableName | |schemaless 自定义的子表名的 key，无缺省值| |smlChildTableName | |schemaless 自定义的子表名的 key，无缺省值|
|smlAutoChildTableNameDelimiter| |schemaless tag 之间的连接符，连起来作为子表名，无缺省值| |smlAutoChildTableNameDelimiter| |schemaless tag 之间的连接符，连起来作为子表名，无缺省值|
|smlTagName | |schemaless tag 为空时默认的 tag 名字，缺省值 "_tag_null"| |smlTagName | |schemaless tag 为空时默认的 tag 名字，缺省值 "_tag_null"|
|smlTsDefaultName | |schemaless 自动建表的时间列名字通过该配置设置，缺省值 "_ts"| |smlTsDefaultName | |schemaless 自动建表的时间列名字通过该配置设置，缺省值 "_ts"|
|smlDot2Underline | |schemaless 把超级表名中的 dot 转成下划线| |smlDot2Underline | |schemaless 把超级表名中的 dot 转成下划线|
|maxInsertBatchRows | |内部参数，一批写入的最大条数| |maxInsertBatchRows | |内部参数，一批写入的最大条数|
### 区域相关 ### 区域相关
|参数名称|支持版本|参数含义| |参数名称|支持版本|参数含义|
|-----------------|-----------|-| |-----------------|----------|-|
|timezone | |时区；缺省从系统中动态获取当前的时区设置| |timezone | |时区；缺省从系统中动态获取当前的时区设置|
|locale | |系统区位信息及编码格式，缺省从系统中获取| |locale | |系统区位信息及编码格式，缺省从系统中获取|
|charset | |字符集编码，缺省从系统中获取| |charset | |字符集编码，缺省从系统中获取|
### 存储相关 ### 存储相关
|参数名称|支持版本|参数含义| |参数名称|支持版本|参数含义|
|-----------------|-----------|-| |-----------------|----------|-|
|tempDir | |指定所有运行过程中的临时文件生成的目录，Linux 平台默认值为 /tmp| |tempDir | |指定所有运行过程中的临时文件生成的目录，Linux 平台默认值为 /tmp|
|minimalTmpDirGB | |tempDir 所指定的临时文件目录所需要保留的最小空间，单位 GB，缺省值：1| |minimalTmpDirGB | |tempDir 所指定的临时文件目录所需要保留的最小空间，单位 GB，缺省值：1|
### 日志相关 ### 日志相关
|参数名称|支持版本|参数含义| |参数名称|支持版本|参数含义|
|-----------------|-----------|-| |-----------------|----------|-|
|logDir | |日志文件目录，运行日志将写入该目录，缺省值：/var/log/taos| |logDir | |日志文件目录，运行日志将写入该目录，缺省值：/var/log/taos|
|minimalLogDirGB | |日志文件夹所在磁盘可用空间大小小于该值时，停止写日志，单位 GB，缺省值：1| |minimalLogDirGB | |日志文件夹所在磁盘可用空间大小小于该值时，停止写日志，单位 GB，缺省值：1|
|numOfLogLines | |单个日志文件允许的最大行数，缺省值：10,000,000| |numOfLogLines | |单个日志文件允许的最大行数，缺省值：10,000,000|
|asyncLog | |日志写入模式，0：同步，1：异步，缺省值：1| |asyncLog | |日志写入模式，0：同步，1：异步，缺省值：1|
|logKeepDays | |日志文件的最长保存时间，单位：天，缺省值：0，意味着无限保存，日志文件不会被重命名，也不会有新的日志文件滚动产生，但日志文件的内容有可能会不断滚动，取决于日志文件大小的设置；当设置为大于 0 的值时，当日志文件大小达到设置的上限时会被重命名为 taoslogx.yyy，其中 yyy 为日志文件最后修改的时间戳，并滚动产生新的日志文件| |logKeepDays | |日志文件的最长保存时间，单位：天，缺省值：0，意味着无限保存，日志文件不会被重命名，也不会有新的日志文件滚动产生，但日志文件的内容有可能会不断滚动，取决于日志文件大小的设置；当设置为大于 0 的值时，当日志文件大小达到设置的上限时会被重命名为 taoslogx.yyy，其中 yyy 为日志文件最后修改的时间戳，并滚动产生新的日志文件|
|debugFlag | |运行日志开关，131（输出错误和警告日志），135（输出错误、警告和调试日志），143（输出错误、警告、调试和跟踪日志）；默认值 131 或 135 （取决于不同模块）| |debugFlag | |运行日志开关，131（输出错误和警告日志），135（输出错误、警告和调试日志），143（输出错误、警告、调试和跟踪日志）；默认值 131 或 135 （取决于不同模块）|
|tmrDebugFlag | |定时器模块的日志开关，取值范围同上| |tmrDebugFlag | |定时器模块的日志开关，取值范围同上|
|uDebugFlag | |共用功能模块的日志开关，取值范围同上| |uDebugFlag | |共用功能模块的日志开关，取值范围同上|
|rpcDebugFlag | |rpc 模块的日志开关，取值范围同上| |rpcDebugFlag | |rpc 模块的日志开关，取值范围同上|
|jniDebugFlag | |jni 模块的日志开关，取值范围同上| |jniDebugFlag | |jni 模块的日志开关，取值范围同上|
|qDebugFlag | |query 模块的日志开关，取值范围同上| |qDebugFlag | |query 模块的日志开关，取值范围同上|
|cDebugFlag | |客户端模块的日志开关，取值范围同上| |cDebugFlag | |客户端模块的日志开关，取值范围同上|
|simDebugFlag | |内部参数，测试工具的日志开关，取值范围同上| |simDebugFlag | |内部参数，测试工具的日志开关，取值范围同上|
|tqClientDebugFlag|3.3.4.3 之后|客户端模块的日志开关，取值范围同上| |tqClientDebugFlag|3.3.4.3 后|客户端模块的日志开关，取值范围同上|
### 调试相关 ### 调试相关
|参数名称|支持版本|参数含义| |参数名称|支持版本|参数含义|
|-----------------|-----------|-| |-----------------|-----------|-|
|crashReporting | |是否上传 crash 到 telemetry，0：不上传，1：上传；缺省值：1| |crashReporting | |是否上传 crash 到 telemetry，0：不上传，1：上传；缺省值：1|
|enableCoreFile | |crash 时是否生成 core 文件，0：不生成，1：生成；缺省值：1| |enableCoreFile | |crash 时是否生成 core 文件，0：不生成，1：生成；缺省值：1|
|assert | |断言控制开关，缺省值：0| |assert | |断言控制开关，缺省值：0|
|configDir | |配置文件所在目录| |configDir | |配置文件所在目录|
|scriptDir | |内部参数，测试用例的目录| |scriptDir | |内部参数，测试用例的目录|
|randErrorChance |3.3.3.0 之后|内部参数，用于随机失败测试| |randErrorChance |3.3.3.0 后|内部参数，用于随机失败测试|
|randErrorDivisor |3.3.3.0 之后|内部参数，用于随机失败测试| |randErrorDivisor |3.3.3.0 后|内部参数，用于随机失败测试|
|randErrorScope |3.3.3.0 之后|内部参数，用于随机失败测试| |randErrorScope |3.3.3.0 后|内部参数，用于随机失败测试|
|safetyCheckLevel |3.3.3.0 之后|内部参数，用于随机失败测试| |safetyCheckLevel |3.3.3.0 后|内部参数，用于随机失败测试|
|simdEnable |3.3.4.3 之后|内部参数，用于测试 SIMD 加速| |simdEnable |3.3.4.3 后|内部参数，用于测试 SIMD 加速|
|AVX512Enable |3.3.4.3 之后|内部参数，用于测试 AVX512 加速| |AVX512Enable |3.3.4.3 后|内部参数，用于测试 AVX512 加速|
### SHELL 相关 ### SHELL 相关
|参数名称|支持版本|参数含义| |参数名称|支持版本|参数含义|
|-----------------|-----------|-| |-----------------|----------|-|
|enableScience | |是否开启科学计数法显示浮点数；0：不开始，1：开启；缺省值：1| |enableScience | |是否开启科学计数法显示浮点数；0：不开始，1：开启；缺省值：1|
## API ## API

2
docs/zh/14-reference/03-taos-sql/03-table.md
View File

@ -227,7 +227,7 @@ DROP TABLE [IF EXISTS] [db_name.]tb_name [, [IF EXISTS] [db_name.]tb_name] ...
如下 SQL 语句可以列出当前数据库中的所有表名。 如下 SQL 语句可以列出当前数据库中的所有表名。
```sql ```sql
SHOW TABLES [LIKE tb_name_wildchar]; SHOW TABLES [LIKE tb_name_wildcard];
``` ```
### 显示表创建语句 ### 显示表创建语句

6
docs/zh/28-releases/03-notes/3.3.4.3.md
View File

@ -3,6 +3,12 @@ title: 3.3.4.3 版本说明
sidebar_label: 3.3.4.3 sidebar_label: 3.3.4.3
description: 3.3.4.3 版本说明 description: 3.3.4.3 版本说明
--- ---
### 行为变更及兼容性
1. 多副本流计算中必须使用 snode
1. 增加了流计算的兼容性保证机制，避免后续函数变更产生新的兼容性问题，但之前版本的流计算必须重建，具体参见 https://docs.taosdata.com/advanced/stream/#流计算升级故障恢复
1. 调整 case when 语句结果类型的判断方法
### 新特性 ### 新特性
1. 新功能：流计算的 TWA 函数支持时间驱动的结果推送模式 1. 新功能：流计算的 TWA 函数支持时间驱动的结果推送模式
1. 新功能：流计算的 Interp 函数支持时间驱动的结果推送模式 1. 新功能：流计算的 Interp 函数支持时间驱动的结果推送模式

3
docs/zh/28-releases/03-notes/index.md
View File

@ -3,6 +3,7 @@ title: 版本说明
sidebar_label: 版本说明 sidebar_label: 版本说明
description: 各版本版本说明 description: 各版本版本说明
--- ---
[3.3.4.3](./3.3.4.3)
[3.3.4.3](./3.3.4.3)
[3.3.3.0](./3.3.3.0) [3.3.3.0](./3.3.3.0)
[3.3.2.0](./3.3.2.0) [3.3.2.0](./3.3.2.0)

3
include/common/tmsg.h
View File

@ -2187,8 +2187,9 @@ int32_t tSerializeSShowVariablesReq(void* buf, int32_t bufLen, SShowVariablesReq
typedef struct { typedef struct {
char name[TSDB_CONFIG_OPTION_LEN + 1]; char name[TSDB_CONFIG_OPTION_LEN + 1];
char value[TSDB_CONFIG_VALUE_LEN + 1]; char value[TSDB_CONFIG_PATH_LEN + 1];
char scope[TSDB_CONFIG_SCOPE_LEN + 1]; char scope[TSDB_CONFIG_SCOPE_LEN + 1];
char info[TSDB_CONFIG_INFO_LEN + 1];
} SVariablesInfo; } SVariablesInfo;
typedef struct { typedef struct {

5
include/libs/nodes/cmdnodes.h
View File

@ -42,10 +42,11 @@ extern "C" {
#define SHOW_CREATE_VIEW_RESULT_FIELD1_LEN (TSDB_VIEW_FNAME_LEN + 4 + VARSTR_HEADER_SIZE) #define SHOW_CREATE_VIEW_RESULT_FIELD1_LEN (TSDB_VIEW_FNAME_LEN + 4 + VARSTR_HEADER_SIZE)
#define SHOW_CREATE_VIEW_RESULT_FIELD2_LEN (TSDB_MAX_ALLOWED_SQL_LEN + VARSTR_HEADER_SIZE) #define SHOW_CREATE_VIEW_RESULT_FIELD2_LEN (TSDB_MAX_ALLOWED_SQL_LEN + VARSTR_HEADER_SIZE)
#define SHOW_LOCAL_VARIABLES_RESULT_COLS 3 #define SHOW_LOCAL_VARIABLES_RESULT_COLS 4
#define SHOW_LOCAL_VARIABLES_RESULT_FIELD1_LEN (TSDB_CONFIG_OPTION_LEN + VARSTR_HEADER_SIZE) #define SHOW_LOCAL_VARIABLES_RESULT_FIELD1_LEN (TSDB_CONFIG_OPTION_LEN + VARSTR_HEADER_SIZE)
#define SHOW_LOCAL_VARIABLES_RESULT_FIELD2_LEN (TSDB_CONFIG_VALUE_LEN + VARSTR_HEADER_SIZE) #define SHOW_LOCAL_VARIABLES_RESULT_FIELD2_LEN (TSDB_CONFIG_PATH_LEN + VARSTR_HEADER_SIZE)
#define SHOW_LOCAL_VARIABLES_RESULT_FIELD3_LEN (TSDB_CONFIG_SCOPE_LEN + VARSTR_HEADER_SIZE) #define SHOW_LOCAL_VARIABLES_RESULT_FIELD3_LEN (TSDB_CONFIG_SCOPE_LEN + VARSTR_HEADER_SIZE)
#define SHOW_LOCAL_VARIABLES_RESULT_FIELD4_LEN (TSDB_CONFIG_INFO_LEN + VARSTR_HEADER_SIZE)
#define COMPACT_DB_RESULT_COLS 3 #define COMPACT_DB_RESULT_COLS 3
#define COMPACT_DB_RESULT_FIELD1_LEN 32 #define COMPACT_DB_RESULT_FIELD1_LEN 32

10
include/util/tdef.h
View File

@ -195,9 +195,9 @@ static const EOperatorType OPERATOR_ARRAY[] = {
OP_TYPE_MULTI, OP_TYPE_MULTI,
OP_TYPE_DIV, OP_TYPE_DIV,
OP_TYPE_REM, OP_TYPE_REM,
OP_TYPE_MINUS, OP_TYPE_MINUS,
OP_TYPE_BIT_AND, OP_TYPE_BIT_AND,
OP_TYPE_BIT_OR, OP_TYPE_BIT_OR,
@ -213,7 +213,7 @@ static const EOperatorType OPERATOR_ARRAY[] = {
OP_TYPE_NOT_LIKE, OP_TYPE_NOT_LIKE,
OP_TYPE_MATCH, OP_TYPE_MATCH,
OP_TYPE_NMATCH, OP_TYPE_NMATCH,
OP_TYPE_IS_NULL, OP_TYPE_IS_NULL,
OP_TYPE_IS_NOT_NULL, OP_TYPE_IS_NOT_NULL,
OP_TYPE_IS_TRUE, OP_TYPE_IS_TRUE,
@ -222,7 +222,7 @@ static const EOperatorType OPERATOR_ARRAY[] = {
OP_TYPE_IS_NOT_TRUE, OP_TYPE_IS_NOT_TRUE,
OP_TYPE_IS_NOT_FALSE, OP_TYPE_IS_NOT_FALSE,
OP_TYPE_IS_NOT_UNKNOWN, OP_TYPE_IS_NOT_UNKNOWN,
//OP_TYPE_COMPARE_MAX_VALUE, //OP_TYPE_COMPARE_MAX_VALUE,
OP_TYPE_JSON_GET_VALUE, OP_TYPE_JSON_GET_VALUE,
OP_TYPE_JSON_CONTAINS, OP_TYPE_JSON_CONTAINS,
@ -631,6 +631,8 @@ enum { RAND_ERR_MEMORY = 1, RAND_ERR_FILE = 2, RAND_ERR_NETWORK = 4 };
#define TSDB_CONFIG_VALUE_LEN 64 #define TSDB_CONFIG_VALUE_LEN 64
#define TSDB_CONFIG_SCOPE_LEN 8 #define TSDB_CONFIG_SCOPE_LEN 8
#define TSDB_CONFIG_NUMBER 16 #define TSDB_CONFIG_NUMBER 16
#define TSDB_CONFIG_PATH_LEN 4096
#define TSDB_CONFIG_INFO_LEN 64
#define QUERY_ID_SIZE 20 #define QUERY_ID_SIZE 20
#define QUERY_OBJ_ID_SIZE 18 #define QUERY_OBJ_ID_SIZE 18

3
source/client/inc/clientInt.h
View File

@ -47,10 +47,11 @@ enum {
RES_TYPE__TMQ_BATCH_META, RES_TYPE__TMQ_BATCH_META,
}; };
#define SHOW_VARIABLES_RESULT_COLS 3 #define SHOW_VARIABLES_RESULT_COLS 4
#define SHOW_VARIABLES_RESULT_FIELD1_LEN (TSDB_CONFIG_OPTION_LEN + VARSTR_HEADER_SIZE) #define SHOW_VARIABLES_RESULT_FIELD1_LEN (TSDB_CONFIG_OPTION_LEN + VARSTR_HEADER_SIZE)
#define SHOW_VARIABLES_RESULT_FIELD2_LEN (TSDB_CONFIG_VALUE_LEN + VARSTR_HEADER_SIZE) #define SHOW_VARIABLES_RESULT_FIELD2_LEN (TSDB_CONFIG_VALUE_LEN + VARSTR_HEADER_SIZE)
#define SHOW_VARIABLES_RESULT_FIELD3_LEN (TSDB_CONFIG_SCOPE_LEN + VARSTR_HEADER_SIZE) #define SHOW_VARIABLES_RESULT_FIELD3_LEN (TSDB_CONFIG_SCOPE_LEN + VARSTR_HEADER_SIZE)
#define SHOW_VARIABLES_RESULT_FIELD4_LEN (TSDB_CONFIG_INFO_LEN + VARSTR_HEADER_SIZE)
#define TD_RES_QUERY(res) (*(int8_t*)(res) == RES_TYPE__QUERY) #define TD_RES_QUERY(res) (*(int8_t*)(res) == RES_TYPE__QUERY)
#define TD_RES_TMQ(res) (*(int8_t*)(res) == RES_TYPE__TMQ) #define TD_RES_TMQ(res) (*(int8_t*)(res) == RES_TYPE__TMQ)

15
source/client/src/clientMsgHandler.c
View File

@ -541,6 +541,10 @@ static int32_t buildShowVariablesBlock(SArray* pVars, SSDataBlock** block) {
infoData.info.bytes = SHOW_VARIABLES_RESULT_FIELD3_LEN; infoData.info.bytes = SHOW_VARIABLES_RESULT_FIELD3_LEN;
TSDB_CHECK_NULL(taosArrayPush(pBlock->pDataBlock, &infoData), code, line, END, terrno); TSDB_CHECK_NULL(taosArrayPush(pBlock->pDataBlock, &infoData), code, line, END, terrno);
infoData.info.type = TSDB_DATA_TYPE_VARCHAR;
infoData.info.bytes = SHOW_VARIABLES_RESULT_FIELD4_LEN;
TSDB_CHECK_NULL(taosArrayPush(pBlock->pDataBlock, &infoData), code, line, END, terrno);
int32_t numOfCfg = taosArrayGetSize(pVars); int32_t numOfCfg = taosArrayGetSize(pVars);
code = blockDataEnsureCapacity(pBlock, numOfCfg); code = blockDataEnsureCapacity(pBlock, numOfCfg);
TSDB_CHECK_CODE(code, line, END); TSDB_CHECK_CODE(code, line, END);
@ -569,6 +573,13 @@ static int32_t buildShowVariablesBlock(SArray* pVars, SSDataBlock** block) {
TSDB_CHECK_NULL(pColInfo, code, line, END, terrno); TSDB_CHECK_NULL(pColInfo, code, line, END, terrno);
code = colDataSetVal(pColInfo, i, scope, false); code = colDataSetVal(pColInfo, i, scope, false);
TSDB_CHECK_CODE(code, line, END); TSDB_CHECK_CODE(code, line, END);
char info[TSDB_CONFIG_INFO_LEN + VARSTR_HEADER_SIZE] = {0};
STR_WITH_MAXSIZE_TO_VARSTR(info, pInfo->info, TSDB_CONFIG_INFO_LEN + VARSTR_HEADER_SIZE);
pColInfo = taosArrayGet(pBlock->pDataBlock, c++);
TSDB_CHECK_NULL(pColInfo, code, line, END, terrno);
code = colDataSetVal(pColInfo, i, info, false);
TSDB_CHECK_CODE(code, line, END);
} }
pBlock->info.rows = numOfCfg; pBlock->info.rows = numOfCfg;
@ -825,7 +836,7 @@ int32_t processCompactDbRsp(void* param, SDataBuf* pMsg, int32_t code) {
tscError("failed to post semaphore"); tscError("failed to post semaphore");
} }
} }
return code; return code;
} }
__async_send_cb_fn_t getMsgRspHandle(int32_t msgType) { __async_send_cb_fn_t getMsgRspHandle(int32_t msgType) {
@ -845,7 +856,7 @@ __async_send_cb_fn_t getMsgRspHandle(int32_t msgType) {
case TDMT_MND_SHOW_VARIABLES: case TDMT_MND_SHOW_VARIABLES:
return processShowVariablesRsp; return processShowVariablesRsp;
case TDMT_MND_COMPACT_DB: case TDMT_MND_COMPACT_DB:
return processCompactDbRsp; return processCompactDbRsp;
default: default:
return genericRspCallback; return genericRspCallback;
} }

3
source/common/src/systable.c
View File

@ -327,8 +327,9 @@ static const SSysDbTableSchema configSchema[] = {
static const SSysDbTableSchema variablesSchema[] = { static const SSysDbTableSchema variablesSchema[] = {
{.name = "dnode_id", .bytes = 4, .type = TSDB_DATA_TYPE_INT, .sysInfo = true}, {.name = "dnode_id", .bytes = 4, .type = TSDB_DATA_TYPE_INT, .sysInfo = true},
{.name = "name", .bytes = TSDB_CONFIG_OPTION_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true}, {.name = "name", .bytes = TSDB_CONFIG_OPTION_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
{.name = "value", .bytes = TSDB_CONFIG_VALUE_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true}, {.name = "value", .bytes = TSDB_CONFIG_PATH_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
{.name = "scope", .bytes = TSDB_CONFIG_SCOPE_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true}, {.name = "scope", .bytes = TSDB_CONFIG_SCOPE_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
{.name = "info", .bytes = TSDB_CONFIG_INFO_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
}; };
static const SSysDbTableSchema topicSchema[] = { static const SSysDbTableSchema topicSchema[] = {

45
source/common/src/tmisce.c
View File

@ -267,7 +267,14 @@ int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol) {
int8_t locked = 0; int8_t locked = 0;
TAOS_CHECK_GOTO(blockDataEnsureCapacity(pBlock, cfgGetSize(pConf)), NULL, _exit); size_t exSize = 0;
size_t index = 0;
SConfigItem* pDataDirItem = cfgGetItem(pConf, "dataDir");
if (pDataDirItem) {
exSize = TMAX(taosArrayGetSize(pDataDirItem->array), 1) - 1;
}
TAOS_CHECK_GOTO(blockDataEnsureCapacity(pBlock, cfgGetSize(pConf) + exSize), NULL, _exit);
TAOS_CHECK_GOTO(cfgCreateIter(pConf, &pIter), NULL, _exit); TAOS_CHECK_GOTO(cfgCreateIter(pConf, &pIter), NULL, _exit);
@ -275,6 +282,7 @@ int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol) {
locked = 1; locked = 1;
while ((pItem = cfgNextIter(pIter)) != NULL) { while ((pItem = cfgNextIter(pIter)) != NULL) {
_start:
col = startCol; col = startCol;
// GRANT_CFG_SKIP; // GRANT_CFG_SKIP;
@ -289,9 +297,18 @@ int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol) {
TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, name, false), NULL, _exit); TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, name, false), NULL, _exit);
char value[TSDB_CONFIG_VALUE_LEN + VARSTR_HEADER_SIZE] = {0}; char value[TSDB_CONFIG_PATH_LEN + VARSTR_HEADER_SIZE] = {0};
int32_t valueLen = 0; int32_t valueLen = 0;
TAOS_CHECK_GOTO(cfgDumpItemValue(pItem, &value[VARSTR_HEADER_SIZE], TSDB_CONFIG_VALUE_LEN, &valueLen), NULL, _exit); SDiskCfg* pDiskCfg = NULL;
if (strcasecmp(pItem->name, "dataDir") == 0 && exSize > 0) {
char* buf = &value[VARSTR_HEADER_SIZE];
pDiskCfg = taosArrayGet(pItem->array, index);
valueLen = tsnprintf(buf, TSDB_CONFIG_PATH_LEN, "%s", pDiskCfg->dir);
index++;
} else {
TAOS_CHECK_GOTO(cfgDumpItemValue(pItem, &value[VARSTR_HEADER_SIZE], TSDB_CONFIG_PATH_LEN, &valueLen), NULL,
_exit);
}
varDataSetLen(value, valueLen); varDataSetLen(value, valueLen);
pColInfo = taosArrayGet(pBlock->pDataBlock, col++); pColInfo = taosArrayGet(pBlock->pDataBlock, col++);
@ -313,8 +330,28 @@ int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol) {
} }
TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, scope, false), NULL, _exit); TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, scope, false), NULL, _exit);
char info[TSDB_CONFIG_INFO_LEN + VARSTR_HEADER_SIZE] = {0};
if (strcasecmp(pItem->name, "dataDir") == 0 && pDiskCfg) {
char* buf = &info[VARSTR_HEADER_SIZE];
valueLen = tsnprintf(buf, TSDB_CONFIG_INFO_LEN, "level %d primary %d disabled %" PRIi8, pDiskCfg->level,
pDiskCfg->primary, pDiskCfg->disable);
} else {
valueLen = 0;
}
varDataSetLen(info, valueLen);
pColInfo = taosArrayGet(pBlock->pDataBlock, col++);
if (pColInfo == NULL) {
code = terrno;
TAOS_CHECK_GOTO(code, NULL, _exit);
}
TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, info, false), NULL, _exit);
numOfRows++; numOfRows++;
} if (index > 0 && index <= exSize) {
goto _start;
}
}
pBlock->info.rows = numOfRows; pBlock->info.rows = numOfRows;
_exit: _exit:
if (locked) cfgUnLock(pConf); if (locked) cfgUnLock(pConf);

13
source/common/src/tmsg.c
View File

@ -5642,6 +5642,12 @@ int32_t tSerializeSShowVariablesRsp(void *buf, int32_t bufLen, SShowVariablesRsp
SVariablesInfo *pInfo = taosArrayGet(pRsp->variables, i); SVariablesInfo *pInfo = taosArrayGet(pRsp->variables, i);
TAOS_CHECK_EXIT(tEncodeSVariablesInfo(&encoder, pInfo)); TAOS_CHECK_EXIT(tEncodeSVariablesInfo(&encoder, pInfo));
} }
for (int32_t i = 0; i < varNum; ++i) {
SVariablesInfo *pInfo = taosArrayGet(pRsp->variables, i);
TAOS_CHECK_RETURN(tEncodeCStr(&encoder, pInfo->info));
}
tEndEncode(&encoder); tEndEncode(&encoder);
_exit: _exit:
@ -5675,6 +5681,13 @@ int32_t tDeserializeSShowVariablesRsp(void *buf, int32_t bufLen, SShowVariablesR
TAOS_CHECK_EXIT(terrno); TAOS_CHECK_EXIT(terrno);
} }
} }
if (!tDecodeIsEnd(&decoder)) {
for (int32_t i = 0; i < varNum; ++i) {
SVariablesInfo *pInfo = taosArrayGet(pRsp->variables, i);
TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pInfo->info));
}
}
} }
tEndDecode(&decoder); tEndDecode(&decoder);

1
source/dnode/mnode/impl/src/mndDnode.c
View File

@ -1103,6 +1103,7 @@ static int32_t mndProcessShowVariablesReq(SRpcMsg *pReq) {
(void)strcpy(info.name, "statusInterval"); (void)strcpy(info.name, "statusInterval");
(void)snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%d", tsStatusInterval); (void)snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%d", tsStatusInterval);
(void)strcpy(info.scope, "server"); (void)strcpy(info.scope, "server");
// fill info.info
if (taosArrayPush(rsp.variables, &info) == NULL) { if (taosArrayPush(rsp.variables, &info) == NULL) {
code = terrno; code = terrno;
goto _OVER; goto _OVER;

6
source/libs/command/src/command.c
View File

@ -954,6 +954,12 @@ static int32_t buildLocalVariablesResultDataBlock(SSDataBlock** pOutput) {
goto _exit; goto _exit;
} }
infoData.info.type = TSDB_DATA_TYPE_VARCHAR;
infoData.info.bytes = SHOW_LOCAL_VARIABLES_RESULT_FIELD4_LEN;
if (taosArrayPush(pBlock->pDataBlock, &infoData) == NULL) {
goto _exit;
}
*pOutput = pBlock; *pOutput = pBlock;
_exit: _exit:

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

@ -3311,11 +3311,11 @@ static int32_t selectCommonType(SDataType* commonType, const SDataType* newType)
} else { } else {
resultType = gDisplyTypes[type2][type1]; resultType = gDisplyTypes[type2][type1];
} }
if (resultType == -1) { if (resultType == -1) {
return TSDB_CODE_SCALAR_CONVERT_ERROR; return TSDB_CODE_SCALAR_CONVERT_ERROR;
} }
if (commonType->type == newType->type) { if (commonType->type == newType->type) {
commonType->bytes = TMAX(commonType->bytes, newType->bytes); commonType->bytes = TMAX(commonType->bytes, newType->bytes);
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
@ -3328,9 +3328,9 @@ static int32_t selectCommonType(SDataType* commonType, const SDataType* newType)
} else { } else {
commonType->bytes = TMAX(TMAX(commonType->bytes, newType->bytes), TYPE_BYTES[resultType]); commonType->bytes = TMAX(TMAX(commonType->bytes, newType->bytes), TYPE_BYTES[resultType]);
} }
commonType->type = resultType; commonType->type = resultType;
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
@ -13127,7 +13127,7 @@ static int32_t extractShowCreateViewResultSchema(int32_t* numOfCols, SSchema** p
} }
static int32_t extractShowVariablesResultSchema(int32_t* numOfCols, SSchema** pSchema) { static int32_t extractShowVariablesResultSchema(int32_t* numOfCols, SSchema** pSchema) {
*numOfCols = 3; *numOfCols = SHOW_LOCAL_VARIABLES_RESULT_COLS; // SHOW_VARIABLES_RESULT_COLS
*pSchema = taosMemoryCalloc((*numOfCols), sizeof(SSchema)); *pSchema = taosMemoryCalloc((*numOfCols), sizeof(SSchema));
if (NULL == (*pSchema)) { if (NULL == (*pSchema)) {
return terrno; return terrno;
@ -13138,13 +13138,17 @@ static int32_t extractShowVariablesResultSchema(int32_t* numOfCols, SSchema** pS
strcpy((*pSchema)[0].name, "name"); strcpy((*pSchema)[0].name, "name");
(*pSchema)[1].type = TSDB_DATA_TYPE_BINARY; (*pSchema)[1].type = TSDB_DATA_TYPE_BINARY;
(*pSchema)[1].bytes = TSDB_CONFIG_VALUE_LEN; (*pSchema)[1].bytes = TSDB_CONFIG_PATH_LEN;
strcpy((*pSchema)[1].name, "value"); strcpy((*pSchema)[1].name, "value");
(*pSchema)[2].type = TSDB_DATA_TYPE_BINARY; (*pSchema)[2].type = TSDB_DATA_TYPE_BINARY;
(*pSchema)[2].bytes = TSDB_CONFIG_SCOPE_LEN; (*pSchema)[2].bytes = TSDB_CONFIG_SCOPE_LEN;
strcpy((*pSchema)[2].name, "scope"); strcpy((*pSchema)[2].name, "scope");
(*pSchema)[3].type = TSDB_DATA_TYPE_BINARY;
(*pSchema)[3].bytes = TSDB_CONFIG_INFO_LEN;
strcpy((*pSchema)[3].name, "info");
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }

97
source/libs/planner/src/planOptimizer.c
View File

@ -3491,37 +3491,77 @@ static void eliminateProjPushdownProjIdx(SNodeList* pParentProjects, SNodeList*
} }
} }
static int32_t eliminateProjOptFindProjPrefixWithOrderCheck(SProjectLogicNode* pProj, SProjectLogicNode* pChild, SNodeList** pNewChildTargets, bool *orderMatch) {
int32_t code = 0;
SNode* pProjection = NULL, *pChildTarget = NULL;
*orderMatch = true;
FORBOTH(pProjection, pProj->pProjections, pChildTarget, pChild->node.pTargets) {
if (!pProjection) break;
if (0 != strcmp(((SColumnNode*)pProjection)->colName, ((SColumnNode*)pChildTarget)->colName)) {
*orderMatch = false;
break;
}
if (pNewChildTargets) {
SNode* pNew = NULL;
code = nodesCloneNode(pChildTarget, &pNew);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListMakeStrictAppend(pNewChildTargets, pNew);
}
if (TSDB_CODE_SUCCESS != code && pNewChildTargets) {
nodesDestroyList(*pNewChildTargets);
*pNewChildTargets = NULL;
break;
}
}
}
return code;
}
static int32_t eliminateProjOptPushTargetsToSetOpChildren(SProjectLogicNode* pSetOp) {
SNode* pChildProj = NULL;
int32_t code = 0;
bool orderMatch = false;
FOREACH(pChildProj, pSetOp->node.pChildren) {
if (QUERY_NODE_LOGIC_PLAN_PROJECT == nodeType(pChildProj)) {
SProjectLogicNode* pChildLogic = (SProjectLogicNode*)pChildProj;
SNodeList* pNewChildTargetsForChild = NULL;
code = eliminateProjOptFindProjPrefixWithOrderCheck(pSetOp, pChildLogic, &pNewChildTargetsForChild, &orderMatch);
if (TSDB_CODE_SUCCESS != code) break;
nodesDestroyList(pChildLogic->node.pTargets);
pChildLogic->node.pTargets = pNewChildTargetsForChild;
alignProjectionWithTarget((SLogicNode*)pChildLogic);
if (pChildLogic->isSetOpProj) {
code = eliminateProjOptPushTargetsToSetOpChildren(pChildLogic);
if (TSDB_CODE_SUCCESS != code) break;
}
}
}
return code;
}
static int32_t eliminateProjOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan, static int32_t eliminateProjOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan,
SProjectLogicNode* pProjectNode) { SProjectLogicNode* pProjectNode) {
SLogicNode* pChild = (SLogicNode*)nodesListGetNode(pProjectNode->node.pChildren, 0); SLogicNode* pChild = (SLogicNode*)nodesListGetNode(pProjectNode->node.pChildren, 0);
int32_t code = 0; int32_t code = 0;
bool isSetOpProj = false;
bool orderMatch = false;
bool sizeMatch = LIST_LENGTH(pProjectNode->pProjections) == LIST_LENGTH(pChild->pTargets);
bool needReplaceTargets = true;
if (NULL == pProjectNode->node.pParent) { if (NULL == pProjectNode->node.pParent) {
SNodeList* pNewChildTargets = NULL; SNodeList* pNewChildTargets = NULL;
code = nodesMakeList(&pNewChildTargets);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
SNode * pProjection = NULL, *pChildTarget = NULL; SNode * pProjection = NULL, *pChildTarget = NULL;
bool orderMatch = true; isSetOpProj =
bool needOrderMatch =
QUERY_NODE_LOGIC_PLAN_PROJECT == nodeType(pChild) && ((SProjectLogicNode*)pChild)->isSetOpProj; QUERY_NODE_LOGIC_PLAN_PROJECT == nodeType(pChild) && ((SProjectLogicNode*)pChild)->isSetOpProj;
if (needOrderMatch) { if (isSetOpProj) {
// For sql: select ... from (select ... union all select ...); // For sql: select ... from (select ... union all select ...);
// When eliminating the outer proj (the outer select), we have to make sure that the outer proj projections and // When eliminating the outer proj (the outer select), we have to make sure that the outer proj projections and
// union all project targets have same columns in the same order. See detail in TD-30188 // union all project targets have same columns in the same order. See detail in TD-30188
FORBOTH(pProjection, pProjectNode->pProjections, pChildTarget, pChild->pTargets) { code = eliminateProjOptFindProjPrefixWithOrderCheck(pProjectNode, (SProjectLogicNode*)pChild,
if (!pProjection) break; sizeMatch ? NULL : &pNewChildTargets, &orderMatch);
if (0 != strcmp(((SColumnNode*)pProjection)->colName, ((SColumnNode*)pChildTarget)->colName)) { if (TSDB_CODE_SUCCESS == code && sizeMatch && orderMatch) {
orderMatch = false; pNewChildTargets = pChild->pTargets;
break; needReplaceTargets = false;
}
SNode* pNew = NULL;
code = nodesCloneNode(pChildTarget, &pNew);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListStrictAppend(pNewChildTargets, pNew);
}
if (TSDB_CODE_SUCCESS != code) break;
} }
} else { } else {
FOREACH(pProjection, pProjectNode->pProjections) { FOREACH(pProjection, pProjectNode->pProjections) {
@ -3530,7 +3570,7 @@ static int32_t eliminateProjOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan*
SNode* pNew = NULL; SNode* pNew = NULL;
code = nodesCloneNode(pChildTarget, &pNew); code = nodesCloneNode(pChildTarget, &pNew);
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
code = nodesListStrictAppend(pNewChildTargets, pNew); code = nodesListMakeStrictAppend(&pNewChildTargets, pNew);
} }
break; break;
} }
@ -3545,12 +3585,13 @@ static int32_t eliminateProjOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan*
return code; return code;
} }
if (eliminateProjOptCanChildConditionUseChildTargets(pChild, pNewChildTargets) && if (eliminateProjOptCanChildConditionUseChildTargets(pChild, pNewChildTargets) && (!isSetOpProj || orderMatch)) {
(!needOrderMatch || (needOrderMatch && orderMatch))) { if (needReplaceTargets) {
nodesDestroyList(pChild->pTargets); nodesDestroyList(pChild->pTargets);
pChild->pTargets = pNewChildTargets; pChild->pTargets = pNewChildTargets;
}
} else { } else {
nodesDestroyList(pNewChildTargets); if (needReplaceTargets) nodesDestroyList(pNewChildTargets);
OPTIMIZE_FLAG_SET_MASK(pProjectNode->node.optimizedFlag, OPTIMIZE_FLAG_ELIMINATE_PROJ); OPTIMIZE_FLAG_SET_MASK(pProjectNode->node.optimizedFlag, OPTIMIZE_FLAG_ELIMINATE_PROJ);
pCxt->optimized = true; pCxt->optimized = true;
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
@ -3573,7 +3614,11 @@ static int32_t eliminateProjOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan*
NODES_CLEAR_LIST(pProjectNode->node.pChildren); NODES_CLEAR_LIST(pProjectNode->node.pChildren);
nodesDestroyNode((SNode*)pProjectNode); nodesDestroyNode((SNode*)pProjectNode);
// if pChild is a project logic node, remove its projection which is not reference by its target. // if pChild is a project logic node, remove its projection which is not reference by its target.
alignProjectionWithTarget(pChild); if (needReplaceTargets) {
alignProjectionWithTarget(pChild);
// Since we have eliminated the outer proj, we need to push down the new targets to the children of the set operation.
if (isSetOpProj && orderMatch && !sizeMatch) code = eliminateProjOptPushTargetsToSetOpChildren((SProjectLogicNode*)pChild);
}
} }
pCxt->optimized = true; pCxt->optimized = true;
return code; return code;

15
source/util/src/tconfig.c
View File

@ -881,11 +881,26 @@ void cfgDumpCfg(SConfig *pCfg, bool tsc, bool dump) {
case CFG_DTYPE_CHARSET: case CFG_DTYPE_CHARSET:
case CFG_DTYPE_TIMEZONE: case CFG_DTYPE_TIMEZONE:
case CFG_DTYPE_NONE: case CFG_DTYPE_NONE:
if (strcasecmp(pItem->name, "dataDir") == 0) {
size_t sz = taosArrayGetSize(pItem->array);
if (sz > 1) {
for (size_t j = 0; j < sz; ++j) {
SDiskCfg *pCfg = taosArrayGet(pItem->array, j);
if (dump) {
(void)printf("%s %s %s l:%d p:%d d:%"PRIi8"\n", src, name, pCfg->dir, pCfg->level, pCfg->primary, pCfg->disable);
} else {
uInfo("%s %s %s l:%d p:%d d:%"PRIi8, src, name, pCfg->dir, pCfg->level, pCfg->primary, pCfg->disable);
}
}
break;
}
}
if (dump) { if (dump) {
(void)printf("%s %s %s\n", src, name, pItem->str); (void)printf("%s %s %s\n", src, name, pItem->str);
} else { } else {
uInfo("%s %s %s", src, name, pItem->str); uInfo("%s %s %s", src, name, pItem->str);
} }
break; break;
} }
} }

2
tests/system-test/0-others/information_schema.py
View File

@ -222,7 +222,7 @@ class TDTestCase:
tdSql.query("select * from information_schema.ins_columns where db_name ='information_schema'") tdSql.query("select * from information_schema.ins_columns where db_name ='information_schema'")
tdLog.info(len(tdSql.queryResult)) tdLog.info(len(tdSql.queryResult))
tdSql.checkEqual(True, len(tdSql.queryResult) in range(281, 282)) tdSql.checkEqual(True, len(tdSql.queryResult) in range(282, 283))
tdSql.query("select * from information_schema.ins_columns where db_name ='performance_schema'") tdSql.query("select * from information_schema.ins_columns where db_name ='performance_schema'")
tdSql.checkEqual(56, len(tdSql.queryResult)) tdSql.checkEqual(56, len(tdSql.queryResult))

38
tests/system-test/2-query/union.py
View File

@ -369,8 +369,46 @@ class TDTestCase:
''' '''
) )
def test_TS_5630(self):
sql = "CREATE DATABASE `ep_iot` BUFFER 256 CACHESIZE 20 CACHEMODEL 'both' COMP 2 DURATION 14400m WAL_FSYNC_PERIOD 3000 MAXROWS 4096 MINROWS 100 STT_TRIGGER 2 KEEP 5256000m,5256000m,5256000m PAGES 256 PAGESIZE 4 PRECISION 'ms' REPLICA 1 WAL_LEVEL 1 VGROUPS 3 SINGLE_STABLE 0 TABLE_PREFIX 0 TABLE_SUFFIX 0 TSDB_PAGESIZE 4 WAL_RETENTION_PERIOD 3600 WAL_RETENTION_SIZE 0"
tdSql.execute(sql, queryTimes=1)
tdLog.info("database ep_iot created")
sql = "CREATE STABLE `ep_iot`.`sldc_dp` (`ts` TIMESTAMP, `data_write_time` TIMESTAMP, `jz1fdgl` DOUBLE, `jz1ssfdfh` DOUBLE, `jz1fdmh` DOUBLE, `jz1gdmh` DOUBLE, `jz1qjrhl` DOUBLE, `jz1zhcydl` DOUBLE, `jz1zkby` DOUBLE, `jz1zzqyl` DOUBLE, `jz1zzqwda` DOUBLE, `jz1zzqwdb` DOUBLE, `jz1zzqll` DOUBLE, `jz1gswd` DOUBLE, `jz1gsll` DOUBLE, `jz1glxl` DOUBLE, `jz1qjrh` DOUBLE, `jz1zhrxl` DOUBLE, `jz1gmjassllfk` DOUBLE, `jz1gmjasslllj` DOUBLE, `jz1gmjbssllfk` DOUBLE, `jz1gmjbsslllj` DOUBLE, `jz1gmjcssllfk` DOUBLE, `jz1gmjcsslllj` DOUBLE, `jz1gmjdssllfk` DOUBLE, `jz1gmjdsslllj` DOUBLE, `jz1gmjessllfk` DOUBLE, `jz1gmjesslllj` DOUBLE, `jz1gmjfssllfk` DOUBLE, `jz1gmjfsslllj` DOUBLE, `jz1zrqwda` DOUBLE, `jz1zrqwdb` DOUBLE, `jz1zrzqyl` DOUBLE, `jz1mmjadl` DOUBLE, `jz1mmjbdl` DOUBLE, `jz1mmjcdl` DOUBLE, `jz1mmjddl` DOUBLE, `jz1mmjedl` DOUBLE, `jz1mmjfdl` DOUBLE, `jz1cyqckwda` DOUBLE, `jz1cyqckwdb` DOUBLE, `jz1njswd` DOUBLE, `jz1nqqxhsckawd` DOUBLE, `jz1nqqxhsckbwd` DOUBLE, `jz1nqqxhsrkawd` DOUBLE, `jz1nqqxhsrkbwd` DOUBLE, `jz1kyqackyqwdsel` DOUBLE, `jz1kyqbckyqwdsel` DOUBLE, `jz1yfjackyqwd` DOUBLE, `jz1yfjbckyqwd` DOUBLE, `jz1trkyqwd` DOUBLE, `jz1trkyqwd1` DOUBLE, `jz1trkyqwd2` DOUBLE, `jz1trkyqwd3` DOUBLE, `jz1tckjyqwd1` DOUBLE, `jz1tckjyqwd2` DOUBLE, `jz1tckyqwd1` DOUBLE, `jz1bya` DOUBLE, `jz1byb` DOUBLE, `jz1pqwda` DOUBLE, `jz1pqwdb` DOUBLE, `jz1gmjadl` DOUBLE, `jz1gmjbdl` DOUBLE, `jz1gmjcdl` DOUBLE, `jz1gmjddl` DOUBLE, `jz1gmjedl` DOUBLE, `jz1gmjfdl` DOUBLE, `jz1yfjadl` DOUBLE, `jz1yfjbdl` DOUBLE, `jz1ycfjadl` DOUBLE, `jz1ycfjbdl` DOUBLE, `jz1sfjadl` DOUBLE, `jz1sfjbdl` DOUBLE, `jz1fdjyggl` DOUBLE, `jz1fdjwggl` DOUBLE, `jz1sjzs` DOUBLE, `jz1zfl` DOUBLE, `jz1ltyl` DOUBLE, `jz1smb` DOUBLE, `jz1rll` DOUBLE, `jz1grd` DOUBLE, `jz1zjwd` DOUBLE, `jz1yl` DOUBLE, `jz1kyqckwd` DOUBLE, `jz1abmfsybrkcy` DOUBLE, `jz1bbmfsybrkcy` DOUBLE, `jz1abjcsdmfytwdzdz` DOUBLE, `jz1bbjcsdmfytwdzdz` DOUBLE, `jz2fdgl` DOUBLE, `jz2ssfdfh` DOUBLE, `jz2fdmh` DOUBLE, `jz2gdmh` DOUBLE, `jz2qjrhl` DOUBLE, `jz2zhcydl` DOUBLE, `jz2zkby` DOUBLE, `jz2zzqyl` DOUBLE, `jz2zzqwda` DOUBLE, `jz2zzqwdb` DOUBLE, `jz2zzqll` DOUBLE, `jz2gswd` DOUBLE, `jz2gsll` DOUBLE, `jz2glxl` DOUBLE, `jz2qjrh` DOUBLE, `jz2zhrxl` DOUBLE, `jz2gmjassllfk` DOUBLE, `jz2gmjasslllj` DOUBLE, `jz2gmjbssllfk` DOUBLE, `jz2gmjbsslllj` DOUBLE, `jz2gmjcssllfk` DOUBLE, `jz2gmjcsslllj` DOUBLE, `jz2gmjdssllfk` DOUBLE, `jz2gmjdsslllj` DOUBLE, `jz2gmjessllfk` DOUBLE, `jz2gmjesslllj` DOUBLE, `jz2gmjfssllfk` DOUBLE, `jz2gmjfsslllj` DOUBLE, `jz2zrqwda` DOUBLE, `jz2zrqwdb` DOUBLE, `jz2zrzqyl` DOUBLE, `jz2mmjadl` DOUBLE, `jz2mmjbdl` DOUBLE, `jz2mmjcdl` DOUBLE, `jz2mmjddl` DOUBLE, `jz2mmjedl` DOUBLE, `jz2mmjfdl` DOUBLE, `jz2cyqckwda` DOUBLE, `jz2cyqckwdb` DOUBLE, `jz2njswd` DOUBLE, `jz2nqqxhsckawd` DOUBLE, `jz2nqqxhsckbwd` DOUBLE, `jz2nqqxhsrkawd` DOUBLE, `jz2nqqxhsrkbwd` DOUBLE, `jz2kyqackyqwdsel` DOUBLE, `jz2kyqbckyqwdsel` DOUBLE, `jz2yfjackyqwd` DOUBLE, `jz2yfjbckyqwd` DOUBLE, `jz2trkyqwd` DOUBLE, `jz2trkyqwd1` DOUBLE, `jz2trkyqwd2` DOUBLE, `jz2trkyqwd3` DOUBLE, `jz2tckjyqwd1` DOUBLE, `jz2tckjyqwd2` DOUBLE, `jz2tckyqwd1` DOUBLE, `jz2bya` DOUBLE, `jz2byb` DOUBLE, `jz2pqwda` DOUBLE, `jz2pqwdb` DOUBLE, `jz2gmjadl` DOUBLE, `jz2gmjbdl` DOUBLE, `jz2gmjcdl` DOUBLE, `jz2gmjddl` DOUBLE, `jz2gmjedl` DOUBLE, `jz2gmjfdl` DOUBLE, `jz2yfjadl` DOUBLE, `jz2yfjbdl` DOUBLE, `jz2ycfjadl` DOUBLE, `jz2ycfjbdl` DOUBLE, `jz2sfjadl` DOUBLE, `jz2sfjbdl` DOUBLE, `jz2fdjyggl` DOUBLE, `jz2fdjwggl` DOUBLE, `jz2sjzs` DOUBLE, `jz2zfl` DOUBLE, `jz2ltyl` DOUBLE, `jz2smb` DOUBLE, `jz2rll` DOUBLE, `jz2grd` DOUBLE, `jz2zjwd` DOUBLE, `jz2yl` DOUBLE, `jz2kyqckwd` DOUBLE, `jz2abmfsybrkcy` DOUBLE, `jz2bbmfsybrkcy` DOUBLE, `jz2abjcsdmfytwdzdz` DOUBLE, `jz2bbjcsdmfytwdzdz` DOUBLE) TAGS (`iot_hub_id` VARCHAR(100), `device_group_code` VARCHAR(100), `device_code` VARCHAR(100))"
tdLog.info("stable ep_iot.sldc_dp created")
tdSql.execute(sql, queryTimes=1)
sql = "insert into ep_iot.sldc_dp_t1 using ep_iot.sldc_dp tags('a','a','a') values(now, now, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9,0,1);"
tdSql.execute(sql, queryTimes=1)
sql = "insert into ep_iot.sldc_dp_t1 using ep_iot.sldc_dp tags('b','b','b') values(now, now, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9,0,1);"
tdSql.execute(sql, queryTimes=1)
sql = "insert into ep_iot.sldc_dp_t1 using ep_iot.sldc_dp tags('c','c','c') values(now, now, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9,0,1);"
tdSql.execute(sql, queryTimes=1)
sql = "insert into ep_iot.sldc_dp_t1 using ep_iot.sldc_dp tags('d','d','d') values(now, now, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9,0,1);"
tdSql.execute(sql, queryTimes=1)
sql = "insert into ep_iot.sldc_dp_t1 using ep_iot.sldc_dp tags('e','e','e') values(now, now, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9,0,1);"
tdSql.execute(sql, queryTimes=1)
sql = "select scdw_code, scdw_name, jzmc, fdgl, jzzt from ((select '01072016' as scdw_code, '盛鲁电厂' as scdw_name, '机组1' as jzmc, last(jz1fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '01072016' as scdw_code, '盛鲁电厂' as scdw_name, '机组2' as jzmc, last(jz2fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '00103673' as scdw_code, '鲁西电厂' as scdw_name, '机组1'as jzmc, last(jz1fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '00103673' as scdw_code, '鲁西电厂' as scdw_name, '机组2'as jzmc, last(jz2fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '01061584' as scdw_code, '富源热电' as scdw_name, '机组1'as jzmc, last(jz1fdjyggl) as fdgl, '填报' as jzzt ,last(ts) as ts from ep_iot.sldc_dp) union all ( select '01061584' as scdw_code, '富源热电' as scdw_name, '机组2'as jzmc, last(jz2fdjyggl) as fdgl, '填报' as jzzt ,last(ts) as ts from ep_iot.sldc_dp)) where scdw_code like '%%';"
tdSql.query(sql, queryTimes=1)
tdSql.checkCols(5)
tdSql.checkRows(6)
sql = "select scdw_name, scdw_code, jzmc, fdgl, jzzt from ((select '01072016' as scdw_code, '盛鲁电厂' as scdw_name, '机组1' as jzmc, last(jz1fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '01072016' as scdw_code, '盛鲁电厂' as scdw_name, '机组2' as jzmc, last(jz2fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '00103673' as scdw_code, '鲁西电厂' as scdw_name, '机组1'as jzmc, last(jz1fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '00103673' as scdw_code, '鲁西电厂' as scdw_name, '机组2'as jzmc, last(jz2fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '01061584' as scdw_code, '富源热电' as scdw_name, '机组1'as jzmc, last(jz1fdjyggl) as fdgl, '填报' as jzzt ,last(ts) as ts from ep_iot.sldc_dp) union all ( select '01061584' as scdw_code, '富源热电' as scdw_name, '机组2'as jzmc, last(jz2fdjyggl) as fdgl, '填报' as jzzt ,last(ts) as ts from ep_iot.sldc_dp)) where scdw_code like '%%';"
tdSql.query(sql, queryTimes=1)
tdSql.checkCols(5)
tdSql.checkRows(6)
sql = "select scdw_name, scdw_code, jzzt from ((select '01072016' as scdw_code, '盛鲁电厂' as scdw_name, '机组1' as jzmc, last(jz1fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '01072016' as scdw_code, '盛鲁电厂' as scdw_name, '机组2' as jzmc, last(jz2fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '00103673' as scdw_code, '鲁西电厂' as scdw_name, '机组1'as jzmc, last(jz1fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '00103673' as scdw_code, '鲁西电厂' as scdw_name, '机组2'as jzmc, last(jz2fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '01061584' as scdw_code, '富源热电' as scdw_name, '机组1'as jzmc, last(jz1fdjyggl) as fdgl, '填报' as jzzt ,last(ts) as ts from ep_iot.sldc_dp) union all ( select '01061584' as scdw_code, '富源热电' as scdw_name, '机组2'as jzmc, last(jz2fdjyggl) as fdgl, '填报' as jzzt ,last(ts) as ts from ep_iot.sldc_dp)) where scdw_code like '%%';"
tdSql.query(sql, queryTimes=1)
tdSql.checkRows(6)
tdSql.checkCols(3)
sql = "select scdw_code, scdw_name, jzmc, fdgl, jzzt,ts from ((select '01072016' as scdw_code, '盛鲁电厂' as scdw_name, '机组1' as jzmc, last(jz1fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '01072016' as scdw_code, '盛鲁电厂' as scdw_name, '机组2' as jzmc, last(jz2fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '00103673' as scdw_code, '鲁西电厂' as scdw_name, '机组1'as jzmc, last(jz1fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '00103673' as scdw_code, '鲁西电厂' as scdw_name, '机组2'as jzmc, last(jz2fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '01061584' as scdw_code, '富源热电' as scdw_name, '机组1'as jzmc, last(jz1fdjyggl) as fdgl, '填报' as jzzt ,last(ts) as ts from ep_iot.sldc_dp) union all ( select '01061584' as scdw_code, '富源热电' as scdw_name, '机组2'as jzmc, last(jz2fdjyggl) as fdgl, '填报' as jzzt ,last(ts) as ts from ep_iot.sldc_dp)) where scdw_code like '%%';"
tdSql.query(sql, queryTimes=1)
tdSql.checkCols(6)
tdSql.checkRows(6)
##tdSql.execute("drop database ep_iot")
def run(self): def run(self):
tdSql.prepare() tdSql.prepare()
self.test_TS_5630()
tdLog.printNoPrefix("==========step1:create table") tdLog.printNoPrefix("==========step1:create table")
self.__create_tb() self.__create_tb()