system.events

包含有关系统中已发生事件数量的信息。例如，在该表中，你可以查看自 ClickHouse server 启动以来已处理的 SELECT 查询数量。

• event (String) — 事件名称。
• value (UInt64) — 发生的事件数量。
• description (String) — 事件描述。

别名：

• name — event 的别名。

SELECT * FROM system.events LIMIT 5

┌─event─────────────────────────────────┬─value─┬─description────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ Query                                 │    12 │ Number of queries to be interpreted and potentially executed. Does not include queries that failed to parse or were rejected due to AST size limits, quota limits or limits on the number of simultaneously running queries. May include internal queries initiated by ClickHouse itself. Does not count subqueries.                  │
│ SelectQuery                           │     8 │ Same as Query, but only for SELECT queries.                                                                                                                                                                                                                │
│ FileOpen                              │    73 │ Number of files opened.                                                                                                                                                                                                                                    │
│ ReadBufferFromFileDescriptorRead      │   155 │ Number of reads (read/pread) from a file descriptor. Does not include sockets.                                                                                                                                                                             │
│ ReadBufferFromFileDescriptorReadBytes │  9931 │ Number of bytes read from file descriptors. If the file is compressed, this will show the compressed data size.                                                                                                                                              │
└───────────────────────────────────────┴───────┴────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘

• system.asynchronous_metrics — 包含定期计算的指标。
• system.metrics — 包含即时计算的指标。
• system.metric_log — 包含表 system.metrics 和 system.events 中指标值的历史记录。
• 监控 — ClickHouse 监控的基本概念。

发起的 ACME API 请求数。

已发出的 ACME 证书订单数量。

发送到 AI 提供商的 HTTP 请求数量。

该查询中所有 AI 函数调用消耗的提示词标记总数。

通过 Linux 或 FreeBSD AIO 接口进行的读取次数

通过 Linux 或 FreeBSD AIO 接口读取的字节数

通过 Linux 或 FreeBSD AIO 接口进行的写入次数

通过 Linux 或 FreeBSD 的 AIO 接口写入的字节数

该查询中所有 AI 函数调用消耗的补全标记总数。

获得 AI 结果的行数。

因配额限制或错误而使用默认值的行数。

服务端 AST fuzzer 尝试执行的模糊测试查询数量。

DNS 解析结果中发现的 HTTP 连接新地址总数

在 HTTP 连接的 DNS 解析结果中已不再返回的过期地址总数

因 HTTP 连接错误而被标记为故障的地址总数

对已排序列进行聚合所花费的总时间

运行时单级聚合哈希表被转换为两级哈希表的次数。

聚合过程中被初始化为两级的哈希表数量。

应用了键等值范围优化的块数

用于聚合的哈希表预分配了多少个元素。

通过 max_network_bandwidth_for_all_users 限流器传输的字节数。

查询因遵守“max_network_bandwidth_for_all_users”限流而休眠的总时长。

分析补丁分区片段索引耗费的总时间

将补丁分区片段应用于块的总耗时

为内存 Arena 分配的字节数 (用于 GROUP BY 等类似操作)

为内存 Arena 分配的块数 (用于 GROUP BY 等类似操作)

异步 INSERT 查询的数据量 (以字节为单位) 。

在异步 INSERT 的哈希 ID 缓存中发现重复哈希 ID 的次数。

与 InsertQuery 相同，但仅用于异步 INSERT 查询。

通过异步 INSERT 查询插入的行数。

查询等待异步加载器作业的总时长。

因异步日志队列已满而从控制台日志中丢弃的消息数量

发送到控制台日志异步队列的消息总数 (包括已接受和已丢弃的消息)

因异步日志队列已满而从错误文件日志中丢弃的消息数

发送到错误文件日志异步队列的消息总数 (包括已接受和已丢弃的消息)

因异步日志队列已满而从文件日志中丢弃的消息数

发送到文件日志异步队列的消息总数 (包括已接受和已丢弃的消息)

由于异步日志队列已满，从 syslog 中丢弃的消息数

发送到 syslog 异步队列的消息总数 (包括已接受和已丢弃的消息)

由于异步日志队列已满，text_log 中有多少条消息被丢弃

已发送到 text_log 异步队列的消息总数 (包括已接收和已丢弃的消息)

异步本地读取中等待异步读取所耗费的时间。

异步读取过程中被忽略的字节数

等待异步远程读取的耗时。

Azure Blob 存储 API CommitBlockList 的调用次数

Azure Blob 存储 API 的 CopyObject 调用次数

Azure Blob 存储 API 的 CreateContainer 调用次数。

Azure Blob 存储 API DeleteObject 调用次数。

Azure API GetObject 调用次数。

Azure Blob 存储 API GetProperties 的调用次数。

被限流器拦截的 Azure GET 请求数。

通过限流器的 Azure GET 请求数：包括被阻止和未被阻止的请求。

查询因遵循 Azure GET 请求限流而休眠的总时长。

Azure Blob 存储 API ListObjects 的调用次数。

被限流器拦截的 Azure PUT 请求数。

经限流器处理的 Azure PUT 请求数量：已阻止和未阻止。

查询因遵循 Azure PUT 请求限流而休眠的总时长。

等待 Azure 读取请求的总耗时。

Azure 读取请求数。

Azure 读取请求错误数。

Azure 读取请求被重定向的次数。

被限流的 Azure 读取请求数。

Azure Blob 存储 API 的 StageBlock 调用次数

Azure Blob 存储 API 的 Upload 调用次数

等待 Azure 写入请求的总耗时。

Azure 写入请求数。

Azure 写入请求错误数。

Azure 写入请求被重定向的次数。

被限流的 Azure 写入请求数。

后台加载标记任务数

创建表数据备份条目所耗费的时间

创建备份条目所花费的时间

创建备份条目后运行后续任务所耗费的时间

创建备份时读取 '.lock' 文件的次数

为备份条目准备文件信息所花费的时间

为计算备份条目的校验和而在本地读取的文件总大小

用于计算备份条目校验和而在本地读取的文件数

读取 .backup 文件中的备份元数据所花费的时间

为计算备份条目的校验和，从远程磁盘读取的文件总大小

为计算备份条目的校验和而从远程磁盘读取的文件数

通过 max_backup_bandwidth_for_server 限流器的字节数。

查询因遵守 max_backup_bandwidth_for_server 限流而休眠的总时长。

写入备份元数据到 .backup 文件所耗费的时间

以只读方式打开的备份数量

用于解锁而打开的备份数量

以写入方式打开的备份数量

BlobCopier 执行期间，对 blob 加锁时发生的错误数量

从元数据存储中返回的 blob 数量

BlobCopier 执行期间发生的 blob 记录错误数量

元数据存储中已记录的由 BlobCopier 复制的 blob 数量

BlobCopier 执行期间发生的 blob 复制错误数

BlobCopier 已复制的 blob 数量

BlobCopier 线程执行次数

BlobKiller 执行期间发生的 blob 加锁错误数量

元数据存储返回的 blob 数量

BlobKiller 执行期间发生的 blob 记录错误次数

BlobKiller 已将其删除操作记录到元数据存储中的 blob 数量

BlobKiller 执行期间发生的 blob 删除错误数

BlobKiller 创建的删除任务数

BlobKiller 删除的 blob 数量

BlobKiller 线程的执行次数

在 Join 模式下应用补丁分区片段时，构建索引和哈希表所花费的总时间

在 Merge 模式下，为应用补丁分区片段构建索引的总耗时

专用后台线程拉取到文件系统缓存的数据量。

CacheWarmer 完整拉取的数据分区片段数量。

从源 (远程文件系统等) 写入到文件系统缓存的字节数

写入文件系统缓存所耗费的时间

准备 buffer 所用时间

从文件系统缓存源读取的字节数。缓存分段会作为一个整体按从左到右的顺序读取，因此为了获取所需数据，可能需要预下载分段中与当前任务无关的部分

用于预下载时从文件系统缓存源 (远程文件系统等) 读取的字节数

预下载时从文件系统缓存源 (如远程文件系统等) 读取所花费的时间

从文件系统缓存中读取的字节数

从文件系统缓存读取时命中缓存的次数。

从文件系统缓存读取所耗费的时间

从文件系统缓存读取时缓存未命中的次数。

从文件系统缓存源 (如远程文件系统等) 读取的字节数

从文件系统缓存源 (如远程文件系统) 读取所耗费的时间

等待内部读取缓冲区的耗时 (包括缓存等待)

从源 (远程文件系统等) 写入文件系统缓存的字节数

将数据写入文件系统缓存所花费的时间

尝试移除临时节点时发生错误的次数。这不是什么问题，因为我们实现的 ZooKeeper 库能够确保 session 会过期，并且该节点会被移除。

由于管道已满或无法写入管道，查询分析器或信号处理程序丢弃的堆栈跟踪数量。

合并已排序列所花费的总时间

对已排序列执行折叠操作所花费的总时间

Common executor 任务在 cancel() 中耗费的时间。

Common executor 任务在 executeStep() 中的耗时。

重置 Common executor 任务所花费的时间。

在 Common executor 中等待任务完成所耗费的时间。

表达式编译所用的字节数。

将表达式编译为 LLVM 代码所花费的总时间。

发起对生成的 LLVM 代码进行编译 (以便为复杂表达式创建融合函数) 的次数。

已编译函数的执行次数。

从压缩源 (文件、网络) 读取的压缩块数 (即彼此独立压缩的数据块) 。

从压缩源 (文件、网络) 读取的未压缩字节数 (即解压后的字节数) 。

压缩块校验和不匹配的次数

因压缩块校验和不匹配而检测到位翻转所耗费的总时间。

因单个比特差异导致压缩块校验和不匹配的次数。

CPU 缩容事件总数

查询因 CPU 插槽被抢占而等待的总时长。

CPU 抢占总次数

受 CPU 插槽容量压力影响而延迟的查询数。争用指标——不包括无争用服务器上的延迟扩容等待。

获取的 CPU 插槽总数

已获取的非竞争性 CPU 槽位总数

在分配时因容量压力而未获分配的 CPU 插槽数量。不包括因惰性分配而暂不分配的插槽。

按照每个查询保底 1 个线程，以及对设置了 'use_concurrency_control' = 0 的查询所授予的 CPU 插槽 数量

CPU 扩容事件总数

查询等待获取 CPU 插槽资源的总时间。

获取到的查询槽位总数

查询等待获取查询槽位的总时长

在连接池中等待可用槽位的总耗时。

获取 Context 锁或尝试获取该锁的次数。这是一个全局锁。

Context 锁等待时长 (微秒)

合并分配 请求的总数

合并分配客户端耗费的总时间

合并分配请求总数

合并分配处理程序耗费的总时间

在 合并协调器 中拉取最新元数据所耗费的总时间

在 合并协调器 内过滤已准备好的合并所耗费的总时间

协调器状态锁被独占获取的总次数

独占锁定协调器状态互斥锁的总耗时

协调器状态锁以 FOR SHARE 方式获取的总次数

获取协调器状态互斥锁共享锁所花费的总时间

在 合并协调器 中使用合并选择器查找合并任务所耗费的总时间

合并协调器 的更新总次数

更新合并协调器状态的总耗时

合并工作线程更新的总次数

工作线程更新已分配 merge 的本地状态所花费的总时间

已成功创建用于合并 ReplicatedMergeTree 中 parts 的日志条目。

已成功创建日志条目，用于对 ReplicatedMergeTree 中的 parts 执行变更。

读取数据时在多种读取方法中进行选择过程中，使用 O_DIRECT 创建读取缓冲区的次数。

尝试为读取数据创建带有 O_DIRECT 的读取缓冲区 (在其他读取方式中进行选择时) 但被操作系统拒绝的次数 (可能由于 filesystem 不支持或其他原因) ，随后回退到普通读取方式。

在多种读取方法中进行选择时，使用 mmap 的读取缓冲区为读取数据而创建的次数。

尝试创建使用 mmap 的读取缓冲区来读取数据 (在其他读取方法中进行选择时) 的次数；但由于文件系统不支持或其他原因，操作系统不允许这样做，因此回退到普通读取方法。

为读取数据而创建普通读取缓冲区的次数 (即在其他读取方法中选择普通读取缓冲区时) 。

DNS 解析错误总数

合并后的数据在字节级别上与其他副本上的数据不完全一致的次数。可能有以下几种原因：

1. 服务器更新后使用了较新版本的压缩库。
2. 使用了另一种压缩方法。
3. 使用了非确定性的压缩算法 (这种情况极不可能) 。
4. 由于代码中的逻辑错误，合并算法表现为非确定性。
5. 由于代码中的 bug，导致内存中的数据损坏。
6. 由于硬件问题，导致内存中的数据损坏。
7. 服务器启动后手动修改了源数据。
8. 手动修改了存储在 ZooKeeper 中的校验和。
9. 与 part 格式相关的设置 (例如 enable_mixed_granularity_parts) 在不同副本上不一致。 服务器已成功检测到这种情况，并将从副本下载合并后的 part，以强制得到字节级别完全一致的结果。

变更后数据与其他副本上的数据在字节级别不一致的次数。除了“DataAfterMergeDiffersFromReplica”中所述的原因外，也可能是由非确定性变更导致的。

函数执行时，由用于处理 NULL 的默认实现处理的行数

函数执行期间，由 NULL 默认实现处理的包含 NULL 值的行数

由于某个分区中活跃的数据分区片段过多，向 MergeTree 表 INSERT 一个块时被限流的次数。

由于分区中的活动数据分区片段过多，将一个块 INSERT 到 MergeTree 表时被限流所花费的总毫秒数。

由于表中存在大量未完成的变更，MergeTree 表的变更被限流的次数。

由于表中未完成的变更数量过多，MergeTree 表的变更被限流期间累计耗费的总毫秒数。

DeltaLake 分区裁剪时跳过的文件数

DeltaLake 扫描回调过程中扫描的文件数量

DeltaLake 表快照初始化 (从对象存储加载) 的次数

在 cache 类型的字典中查找到、且在缓存中命中但已失效的键数量。

在 cache 类型的字典中查找并在缓存中命中的键数量。

在 cache 类型字典中查找但未找到的键数量。

为 cache 类型的字典从数据源请求的键数。

从数据源请求并在数据源中找到的 cache 类型字典键数量。

对于 cache 类型的字典，从数据源请求但未在数据源中找到的键数量。

为 cache 类型的字典查找数据时，等待获取读锁所花费的纳秒数。

为更新 cache 类型字典数据而等待写锁所耗费的纳秒数。

查询 cache 类型字典所使用的外部数据源时耗费的纳秒数。

针对 cache 类型字典向外部数据源发出的批量请求次数。

对目录调用 F_FULLFSYNC/fsync/fdatasync 函数的次数。

等待目录执行 F_FULLFSYNC/fsync/fdatasync 系统调用所耗费的总时间。

Disk Azure blob 存储 API CommitBlockList 的调用次数

Disk Azure blob 存储 API 的 CopyObject 调用次数

Disk Azure blob 存储 API 中 CreateContainer 的调用次数。

Azure Blob 存储 API DeleteObject 调用次数。

Disk Azure API GetObject 的调用次数。

Disk Azure blob 存储 API GetProperties 的调用次数。

被限流器拦截的 Azure 磁盘 GET 请求数。

经过限流器的 Azure 磁盘 GET 请求数：包括被阻止和未被阻止的请求。

查询因遵循 Azure 磁盘 GET 请求限流而休眠的总时长。

Disk Azure blob 存储 API 的 ListObjects 调用次数。

被限流器拦截的 Azure 磁盘 PUT 请求数。

通过限流器的 Azure 磁盘 PUT 请求数：包括被阻止和未被阻止的请求。

查询因遵守 Azure 磁盘 PUT 请求限流而休眠的总时长。

等待 Azure 磁盘读取请求所花费的总时间。

Azure 磁盘读取请求数。

Azure 磁盘读取请求错误次数。

Azure 磁盘读取请求被重定向的次数。

受限流的 Azure 磁盘读取请求数量。

Disk Azure Blob 存储 API 的 StageBlock 调用次数

Disk Azure blob 存储 API 上传调用次数

等待 Azure 磁盘写入请求所花费的总时间。

Azure 磁盘写请求数。

Azure 磁盘写入请求错误的数量。

Azure 磁盘写入请求的重定向次数。

Azure 磁盘写入请求被限流的数量。

磁盘已创建的连接数

用于创建磁盘连接的总耗时

为磁盘创建连接失败的次数

磁盘的过期连接数

磁盘保留连接数

磁盘被重置的连接数

磁盘复用连接数

提交元数据事务后，等待待删除 blob 被移除所花费的时间

由 AzureObjectStorage 使用的 'plain_rewritable' 元数据存储创建的目录数量。

被用于 AzureObjectStorage 的 'plain_rewritable' 元数据存储删除的目录数量。

采用旧版布局的 plain_rewritable 磁盘数量。

由 LocalObjectStorage 的 'plain_rewritable' 元数据存储创建的目录数量。

由 LocalObjectStorage 的 'plain_rewritable' 元数据存储删除的目录数量。

由 'plain_rewritable' 元数据存储为 S3ObjectStorage 创建的目录数。

S3ObjectStorage 中由 'plain_rewritable' 元数据存储移除的目录数量。

等待读取系统调用所花费的总时间。这包括从页缓存进行的读取。

DiskS3 API 的 AbortMultipartUpload 调用次数。

DiskS3 API 的 CompleteMultipartUpload 调用次数。

DiskS3 API 的 CopyObject 调用次数。

DiskS3 API 的 CreateMultipartUpload 调用次数。

DiskS3 API DeleteObject 调用次数。

DiskS3 API 的 GetObject 调用次数。

DiskS3 API GetObjectTagging 的调用次数。

被限流器拦截的 DiskS3 GET 和 SELECT 请求数。

通过限流器的 DiskS3 GET 和 SELECT 请求数：包括被阻止和未被阻止的请求。

查询因遵循 DiskS3 的 GET 和 SELECT 请求限流而进入休眠状态的总时长。

DiskS3 API 的 HeadObject 调用次数。

DiskS3 API 的 ListObjects 调用次数。

DiskS3 API 的 PutObject 调用次数。

遭限流器拦截的 DiskS3 PUT、COPY、POST 和 LIST 请求数量。

通过限流器的 DiskS3 PUT、COPY、POST 和 LIST 请求数：包括被阻止和未被阻止的请求。

查询为满足 DiskS3 的 PUT、COPY、POST 和 LIST 请求限流而休眠的总时长。

对 DiskS3 存储 发出的 GET 和 HEAD 请求耗时。

对 DiskS3 存储发起的 GET 和 HEAD 请求的尝试次数，包括首次尝试和任何重试，但不包括由 S3 重试策略在内部执行的重试

对 DiskS3 存储发起的 GET 和 HEAD 请求中可重试错误的数量，不包括由 S3 重试策略在内部执行的重试次数

对 DiskS3 存储发出的 GET 和 HEAD 请求数。

对 DiskS3 存储发起 GET 和 HEAD 请求时发生的非限流错误数。

DiskS3 存储中 GET 和 HEAD 请求发生重定向的次数。

DiskS3 存储中 GET 和 HEAD 请求返回的 429 和 503 错误数量。

DiskS3 API 的 UploadPart 调用次数。

DiskS3 API UploadPartCopy 调用的次数。

向 DiskS3 存储发起 POST、DELETE、PUT 和 PATCH 请求所耗费的时间。

对 DiskS3 存储发起的 POST、DELETE、PUT 和 PATCH 请求的尝试次数，包括首次尝试和任何重试，但不包括由重试策略在内部执行的重试

向 DiskS3 存储发起的 POST、DELETE、PUT 和 PATCH 请求中可重试错误的数量，不包括重试策略在内部执行的重试

对 DiskS3 存储发起的 POST、DELETE、PUT 和 PATCH 请求次数。

对 DiskS3 存储发起的 POST、DELETE、PUT 和 PATCH 请求中，非限流错误的数量。

向 DiskS3 存储发出的 POST、DELETE、PUT 和 PATCH 请求中的重定向次数。

DiskS3 存储上的 POST、DELETE、PUT 和 PATCH 请求中 429 和 503 错误的数量。

等待写入 syscall 的总耗时。这包括写入 page cache 的时间。

分布式缓存连接事件。连接到分布式缓存的尝试次数

Distributed Cache 客户端事件。表示在发出请求前连接分布式缓存服务器失败的次数 (每个请求仅计一次：在所有连接尝试均已耗尽后才计数，而不是像 DistrCacheUnsuccessfulConnectAttempts 那样按每次尝试计数) 。等待连接池中出现空闲连接时发生的超时也计入此项。请求创建期间重连失败则计入 DistrCacheMakeRequestErrors。

分布式缓存连接事件。连接分布式缓存所耗费的时间

分布式缓存读取缓冲区事件。从后备缓冲区而非分布式缓存读取所耗费的时间

分布式缓存连接事件。获取分布式缓存客户端所花费的时间

Distributed Cache 客户端事件。等待分布式缓存响应的耗时

Distributed Cache registry 事件。分布式缓存哈希环重建的次数

Distributed Cache registry 事件。获取 DistributedCacheRegistry 锁所耗费的时间

Distributed Cache 客户端事件。发起请求时发生的分布式缓存错误数

分布式缓存读取缓冲区事件。在 ReadBufferFromDistributedCache::nextImpl 中花费的时间

分布式缓存写入缓冲区事件。写入对象存储的字节数

分布式缓存写入缓冲区事件。写入对象存储的耗时

分布式缓存连接事件。分布式缓存的打开连接数

分布式缓存连接事件。绕过连接池的分布式缓存开放连接数

分布式缓存读取缓冲区事件。预先计算读取范围所花费的时间

分布式缓存读取缓冲区事件。因寻道或 last_position 变化而调整读取范围的次数

分布式缓存读取缓冲区事件。由于寻道或 last_position 变化而重置读取范围的次数

分布式缓存读取缓冲区事件。由于 寻道/last_position 变化而重置读取范围的次数

分布式缓存读取缓冲区事件。从后备缓冲区读取的字节数

Distributed Cache 客户端事件。读取请求期间发生的分布式缓存错误总数 (等于 DistrCacheReadErrorsRetriable + DistrCacheReadErrorsNonRetriable)

Distributed Cache 客户端事件。读取请求期间发生的不可重试分布式缓存错误数

Distributed Cache 客户端事件。读取请求期间发生的可重试分布式缓存错误数 (每次发生都会计数，包括通过重试恢复的错误)

分布式缓存读取缓冲区事件。从分布式缓存读取所花费的时间

分布式缓存读取缓冲区事件。发生可重试错误后，读取请求的重试次数 (包括初始请求创建时的重试)

分布式缓存读取缓冲区事件。可重试的读取错误在读取请求重试次数上限内仍未成功的次数

通过 max_distributed_cache_read_bandwidth_for_server 限流器传输的字节数。

查询为符合 'max_distributed_cache_read_bandwidth_for_server' 限流要求而休眠的总时长。

Distributed Cache 客户端事件。接收请求的响应时发生的分布式缓存错误数

Distributed Cache 客户端事件。从分布式缓存收到的 RefreshCredentials 数据包总数

Distributed Cache 客户端事件。从分布式缓存接收的数据包总数

Distributed Cache 客户端事件。从分布式缓存接收的 Data 数据包的字节数

Distributed Cache 客户端事件。接收自分布式缓存的 Error 数据包总数

Distributed Cache 客户端事件。接收到的来自 Distributed Cache 的 Ok 数据包总数

Distributed Cache 客户端事件。接收到的来自分布式缓存的 Stop 数据包总数

Distributed Cache registry 事件。更新分布式缓存 registry 所耗费的时间

Distributed Cache registry 事件。分布式缓存 registry 的更新次数

分布式缓存连接事件。表示从连接池中移除过期连接所耗费的时间

分布式缓存连接事件。分布式缓存中复用的连接数

Distributed Cache 客户端事件。发送到 Distributed Cache 的数据包总数

Distributed Cache 客户端事件。发送到分布式缓存的 Data 数据包字节数

Distributed Cache 服务器事件。DistributedCacheServer 中 AckRequest 包的数量

Distributed Cache 服务器事件。表示从文件系统缓存读取时，分布式缓存命中缓存的次数

Distributed Cache 服务器事件。从文件系统缓存读取时，分布式缓存发生缓存未命中的次数

Distributed Cache 服务器事件。表示从文件系统缓存读取时，为分布式缓存预下载而从对象存储读取的字节数。

Distributed Cache 服务器事件。在从文件系统缓存读取数据时，分布式缓存中从缓存读取的字节数

Distributed Cache 服务器事件。从文件系统缓存读取时写入分布式缓存的字节数

Distributed Cache 服务器事件。在从文件系统缓存读取时，分布式缓存中从对象存储读取的字节数。

Distributed Cache 服务器事件。DistributedCacheServer 中 ContinueRequest 包的数量

Distributed Cache 服务器事件。已刷新的过期凭据数量

Distributed Cache 服务器事件。DistributedCacheServer 中 EndRequest 数据包数量

Distributed Cache 服务器事件。新缓存的 S3 客户端数量

Distributed Cache 服务器事件。在 DistributedCache 服务器端处理请求所花费的时间

Distributed Cache 服务器事件。DistributedCacheServer 中收到的 RefreshCredentials 客户端数据包数量

Distributed Cache 服务器事件。复用的已缓存 S3 客户端数量

Distributed Cache 服务器事件。服务器关闭期间，在 shutdownAllConnections 中等待活动连接完成 (或被强制关闭) 所耗费的时间

Distributed Cache 服务器事件。因之前的连接尝试失败而跳过分布式缓存服务器的次数。

Distributed Cache 服务器事件。表示 DistributedCacheServer 中 StartRequest 数据包的数量。

分布式缓存读取缓冲区事件。在读穿/写穿缓存中，分布式缓存各服务器之间切换的次数

Distributed Cache 事件。由于哈希选中的服务器发生变化 (例如服务器被取消注册) ，读写期间发生的服务器切换次数

分布式缓存连接事件。因连接池中的连接已失效 (被对端关闭) 而发生的重连次数

分布式缓存读取缓冲区事件。使用分布式缓存启动新读取范围所耗费的时间

分布式缓存连接事件。成功连接到分布式缓存的次数

Distributed Cache registry 事件。服务器 registry 成功更新的次数

Distributed Cache 客户端事件。在请求内部信息系统表 (system.distributed_cache、system.distributed_cache_metrics、system.distributed_cache_events) 时发生的分布式缓存错误数量。这些请求不会重试，因此可重试错误和不可重试错误会合并统计

分布式缓存连接事件。在分布式缓存中创建的临时 File 的写入字节数

分布式缓存连接事件。分布式缓存中创建的临时 File 的数量

分布式缓存连接事件。连接到分布式缓存失败的尝试次数

Distributed Cache registry 事件。服务器 registry 更新未成功的次数

Distributed Cache 客户端事件。被忽略的 Data 数据包所包含的字节数

Distributed Cache 客户端事件。从分布式缓存中跳过的未使用数据包数

Distributed Cache 客户端事件。在无法复用现有缓冲区时发生的额外缓冲区分配次数

分布式缓存写入缓冲区事件。写入分布式缓存的字节数。

Distributed Cache 客户端事件。写入请求期间发生的分布式缓存错误总数 (等于 DistrCacheWriteErrorsRetriable + DistrCacheWriteErrorsNonRetriable) 。由服务器发起的直写缓存 Stop 属于流量控制，而非错误，因此不计入其中

Distributed Cache 客户端事件。写入请求期间发生的不可重试的分布式缓存错误数量

Distributed Cache 客户端事件。写请求期间发生的可重试分布式缓存错误次数 (每次发生都会计数，包括通过重试恢复的错误)

分布式缓存写入缓冲区事件。在 WriteBufferFromDistributedCache::writeToFileSegment 中耗费的时间

分布式缓存写入缓冲区事件。发生可重试错误后的写入请求重试次数

分布式缓存写入缓冲区事件。可重试的写入错误在写请求重试次数上限内仍未成功的次数

通过 max_distributed_cache_write_bandwidth_for_server 限流器的字节数。

查询因遵守 max_distributed_cache_write_bandwidth_for_server 限流而休眠的总时长。

异步插入到 分布式表 的失败次数 (当 'distributed_foreground_insert' = 0 时)

在分布式查询执行期间，与其他服务器建立连接的次数。当建立新的连接而不是复用连接池中的现有连接时，就会出现这种情况。

分布式连接在所有重试都完成后仍失败的总次数。

分布式连接失败并重试时的总次数。

在分布式查询中，因副本不包含查询所需表而拒绝该副本的次数。

在分布式查询执行期间，对其他服务器进行重连的次数。当从连接池中获取到失效连接时，可能会发生这种情况。

在向 分布式表 执行 INSERT 时，因副本处于只读状态而被跳过的副本数量

在分布式查询中，由于查询所需的某张表的复制延迟超过配置的阈值而拒绝副本的次数。

分布式连接尝试总次数。

与可用服务器 (包含所需表，但可能已过时) 建立成功的分布式连接总数。

由于待处理字节数过多，向 分布式表 插入数据块时被限流的次数。

由于待处理字节数过多，向 分布式表 INSERT 一个块时因被限流而耗费的总毫秒数。

分布式索引分析所耗费的总时间

分布式索引分析期间缺失且将由本地处理的 parts 数量

发送用于分布式索引分析的 parts 数量

分布式索引分析在某个副本上失败后回退到本地副本的次数

分布式索引分析在某个副本上失败且未进行回退的次数 (连接时失败)

已安排执行分布式索引分析的副本数量 (本地副本仅计算一次)

使用 make_distributed_plan 执行查询时，至少分配到一个任务的不同主机数。

当 make_distributed_plan 查询由本地执行器 (distributed_plan_execute_locally) 在进程内执行，而不是分派给远程工作线程时，其值为 1。

执行使用 make_distributed_plan 的查询时，派发到远程工作线程的任务数量。非零值表示该查询确实以分布式方式执行。

由于待处理字节数过多，将一个块 INSERT 到分布式表时因出现“Too many bytes”异常而被拒绝的次数。

在同步向 分布式表 插入数据 (distributed_foreground_insert = 1) 时，等待分片的过程超时

插入到 ReplicatedMergeTree 表的块中，被去重的异步插入数量。

同步插入到 *MergeTree 表时被去重的插入次数。

检查插入到 *MergeTree 表中的块是否重复所花费的总时间。

使用文件的表引擎 (如 File/S3/URL/HDFS) 读取的文件数量。

执行可执行用户自定义函数及 可执行池用户自定义函数所耗费的挂钟时间，以微秒计。

写入可执行用户自定义函数及可执行池用户自定义函数子进程标准输入 (stdin) 的总字节数。

可执行用户自定义函数及可执行池用户自定义函数的调用次数。

从可执行用户自定义函数及可执行池用户自定义函数子进程的 stdout 中读取的总字节数。

可执行用户自定义函数及可执行池用户自定义函数的子进程按每个进程计算的峰值内存占用，并按挂钟时间积分，单位为字节秒。

当可执行池用户自定义函数池耗尽时，等待 tryBorrowObject 的耗时，单位为微秒。

可执行用户自定义函数及 可执行池用户自定义函数的子进程在内核态消耗的 CPU 时间，以微秒为单位。

可执行用户自定义函数及可执行池用户自定义函数子进程所消耗的用户态 CPU 时间，单位为微秒。

执行 shell 命令的次数。

外部内存聚合写入磁盘的字节数。

在外部内存中进行聚合时，临时 File 的合并次数。

在外部内存中进行聚合时写入磁盘的未压缩数据量 (即压缩前) 。

使用外部内存进行聚合时，临时 File 写入磁盘的次数。

RemoteReadBufferCache 中从本地缓存缓冲区读取的字节数

JOIN 在外部内存中写入的压缩字节数。

在外部内存中执行 JOIN 时合并临时 File 的次数。

JOIN 在外部内存中写入的数据量 (未压缩，即压缩前的大小) 。

JOIN 使用外部内存时将临时 File 写入磁盘的次数。

外部处理 (排序/聚合/连接) 写入的压缩数据字节数

用于外部处理 (排序/聚合/连接) 的文件数

外部处理 (排序/聚合/连接) 写入的未压缩数据量 (压缩前)

在外部内存中排序时写入的压缩字节数。

在外部内存中排序时，临时 File 合并的次数。

在外部内存中进行排序时写入的数据量 (未压缩，即压缩前的数据) 。

在外部内存排序过程中，临时 File 写入磁盘的次数。

失败的 ASYNC INSERT 查询数。

初始查询失败次数。

与 FailedInitialQuery 相同，但仅用于 SELECT 查询。

与 FailedQuery 相同，但仅针对 INSERT 查询。

与 FailedInternalQuery 相同，但仅用于 INSERT 查询。

失败的内部查询数。

与 FailedInternalQuery 相同，但仅针对 SELECT 查询。

失败查询总数，包括内部查询和用户查询。

与 FailedQuery 相同，但仅针对 SELECT 查询。

Fetch 执行器任务在 cancel() 中花费的时间。

Fetch executor 任务执行 executeStep() 所花费的时间。

重置 Fetch 执行器任务所花费的时间。

在 Fetch 执行器中等待完成的耗时。

已打开的文件数量。

每个查询的 FileProgressCallback 被调用的次数 (统计通过原生 TCP 或 clickhouse-local 传递给客户端的每个文件 FileProgress 事件) 。

文件系统缓存中 FileSegment::complete() 的耗时

因缓存锁竞争严重而未提升优先级的次数

File 段持有器 complete() 耗时

File 段优先级提升时间

锁定 File 段耗时

File 段 remove() 耗时

在 DOWNLOADING 状态下等待

File 段 write() 耗时

对文件调用 F_FULLFSYNC/fsync/fdatasync 函数的次数。

等待文件执行 F_FULLFSYNC/fsync/fdatasync 系统调用所耗费的总时间。

文件系统缓存中被发送到后台下载队列的 File 段数量

后台线程淘汰的字节数

后台线程淘汰的 File 段数量

被后台清理线程清理的已失效 (延迟移除的) 优先队列条目数量

FileCache::assertCacheCorrectness 被调用的次数

FileCache::assertCacheCorrectness 耗费的时间

已创建的键目录数

在 SLRU 缓存策略中，从 protected 队列降级 (移入) 到 probationary 队列的 File 段数量。这是缓存内部的移动，不属于淘汰。

文件系统缓存淘汰时间

从文件系统缓存中淘汰的字节数

从文件系统缓存中淘汰的 File 段数量

文件系统缓存迭代器复用次数

因处于正在驱逐状态而被跳过的 File 段数量

因处于不可释放状态而跳过淘汰的 File 段数量

因处于移动状态而被跳过驱逐的 File 段数量

文件系统缓存淘汰尝试次数

由于缓存正在调整大小而跳过预留空间的次数

因缓存锁竞争严重而未进行空间预留的次数

在动态文件系统缓存淘汰期间，意外未被成功淘汰的 File 段数量

文件缓存空间预留失败次数。

后台可用空间维护任务 (收集、移除或完成) 捕获的异常数量

后台线程执行空闲空间保持任务的次数

后台线程执行空闲空间维护任务的时长

文件系统缓存 get() 耗时

文件系统缓存 getOrSet() 耗时

已持有的文件系统缓存 File 段数量

后台线程执行已失效优先队列条目清理任务所用的时间

加载文件系统缓存元数据所用时间

锁定缓存键所用时间

锁定文件系统缓存元数据所用时间

为弥补预留量缺口，overcommit 淘汰循环在首次遍历后额外执行的外层迭代次数

优先队列读取时文件系统缓存的加锁时间

写入优先队列时锁定文件系统缓存的时间

文件系统缓存空间预留尝试次数

文件系统缓存空间预留耗时

状态锁的文件系统缓存锁定时间

已持有但未使用的文件系统缓存 File 段数量 (例如由于寻道或 LIMIT n 等原因)

在 filterPartsByVirtualColumns 函数中消耗的总时间。

查询中过滤器放行的字节数

查询中过滤后保留的行数

按 PK 过滤 parts 耗费的时间。

主键分析期间处理的标记总数。

使用跳过索引过滤 parts 所花费的时间。

SQL 常规函数调用次数 (SQL 函数按块调用，因此该数值表示块的数量) 。

在合并的垂直阶段收集的列数。

垂直合并期间收集各列所耗费的总时间

超出全局内存限制的次数。

统计全局线程池新增线程的总次数。该指标反映了全局线程池为满足不断增长的处理需求而扩容的频率。

用于衡量一个作业从在线程池中被调度开始，到被工作线程接手执行之间的耗时。该指标有助于识别作业处理延迟，反映线程池对新任务的响应能力。

统计已提交到全局线程池的作业数量。

线程在全局线程池中等待锁的总耗时。

统计全局线程池通过移除线程而收缩的总次数。当空闲线程数超过 max_thread_pool_free_size 时，就会出现这种情况，表明在线程利用率下降时，全局线程池会相应缩减其大小。

等待新线程启动的总耗时。

已创建的客户端 HTTP 连接数

创建客户端 HTTP 连接所花费的总时间

客户端 HTTP 连接创建失败的次数

已过期的客户端 HTTP 连接数

保留的客户端 HTTP 连接数量

已重置的客户端 HTTP 连接数

复用的客户端 HTTP 连接数

已关闭的服务器 HTTP 连接数。未启用 Keep-Alive

已创建的服务器 HTTP 连接数

已过期的服务器 HTTP 连接数。

保留的服务器 HTTP 连接数。连接已成功保持存活

被重置的服务器 HTTP 连接数。服务器关闭连接。

复用的服务器 HTTP 连接数

查询执行线程中的硬缺页错误数量。数值较高表明：要么你忘记在服务器上关闭 swap，要么是在内存压力极高时 ClickHouse 可执行文件的内存页被驱逐，要么是成功使用了表数据的 mmap 读取方法。

哈希连接所用哈希表中预分配的元素数量。

在对冲请求中，切换副本超时的总次数。

为 IO 缓冲区 (ReadBuffer/WriteBuffer) 分配的字节数。

IO 缓冲区 (ReadBuffer/WriteBuffer) 的分配次数。

成功完成的 io_uring CQE 数量总计

已完成但失败的 io_uring CQE 总数

异步 io_uring SQE 重新提交的总次数

同步 io_uring SQE 重新提交的总次数

提交的 io_uring SQE 总数

同步初始化 Iceberg 数据迭代器所花费的总时间。

在缓存中命中 Iceberg 元数据文件的次数。

Iceberg 元数据文件在 Iceberg 元数据缓存中未命中，因此必须从 (远程) 磁盘读取的次数。

在缓存中找到了 Iceberg 元数据文件，但因其已陈旧，仍需从 (远程) 磁盘读取的次数。

从 Iceberg 元数据缓存中被淘汰的字节数近似值。

所有读取线程在等待 Iceberg 元数据文件被读取和解析时耗费的总时间之和。

Iceberg 迭代器返回的对象信息总数。

从状态更新 Iceberg 存储元数据所耗费的总时间 (buildStorageMetadataFromState) 。

借助 Iceberg 中的 MinMax 索引跳过的文件数

在按分区和序列号筛选后适用的配对中，经 minmax 分析判定为可接受的数据文件-位置删除文件对总数。

通过 minmax 分析，在按分区和序列号筛选后符合条件的配对中，被接受的数据文件-position delete file 对总数。

Iceberg 分区剪枝期间跳过的文件数量

读取 Iceberg 时应用了简单计数优化

version-hint.text 的使用次数。

请参见设置 ignore_cold_parts_seconds。该指标表示读取查询忽略非常新的 parts 的次数——这些 parts 尚未被 CacheWarmer 拉取到缓存中。

查询过程中执行索引分析的次数。

在索引标记上执行二分查找算法的次数

在索引标记上使用 generic exclusion search algorithm 的次数

与 Query 相同，但仅统计初始查询 (见 is_initial_query) 。

与 InitialQuery 相同，但仅用于 SELECT 查询。

统计包含其所有子查询的 INSERT 查询数量

与 Query 相同，但仅用于 INSERT 查询。

INSERT 查询耗费的总时间。

插入到所有表中的字节数 (未压缩；按列在内存中的存储形式计算) 。

以 Compact 格式插入的 parts 数量。

插入到所有表中的行数。

以 Wide 格式插入的 parts 数量。

通过 HTTP 接口接收的字节总数

通过 HTTP 接口发送的字节数

通过服务器间接口接收的字节数

通过服务器间接口发送的字节总数

通过 MySQL 接口接收的字节数

通过 MySQL 接口发送的字节数

通过原生接口接收的字节数

通过原生接口发送的字节数

通过 PostgreSQL 接口接收的字节数

经 PostgreSQL 接口发送的字节数

经由 Prometheus 接口接收的字节数

通过 Prometheus 接口发送的字节数

jemalloc 分配样本跟踪失败的总次数

jemalloc 释放样本跟踪失败的总次数

构建右侧 JOIN 端后，后处理步骤所耗费的时间。

JOIN 操作中构建表中的总行数。

DelayedJoinedBlocksWorkerTransform 输出的块数。

DelayedJoinedBlocksWorkerTransform 输出的行数。

NonJoinedBlocksTransform 输出的块数。

由 NonJoinedBlocksTransform 输出的未匹配行数。

执行 JOIN 执行计划优化所花费的总时间。

JOIN 操作中探测表中的总行数。

执行 JOIN 重排算法的总耗时。

JOIN 操作结果的总行数。

在 SpillingHashJoin 中因达到内存限制而从 (Concurrent)HashJoin 切换为 GraceHashJoin 的次数。

自 server 启动以来，从 Kafka 读取并填充 materialized views 的后台读取次数

向 Kafka 提交已消费偏移量失败的次数 (通常意味着存在数据重复)

成功将已消费的偏移量提交到 Kafka 的次数 (通常应与 KafkaBackgroundReads 相同)

librdkafka 在轮询过程中报告的错误数量

自 server 启动以来，直接从 Kafka 表发起的查询次数

向未就绪的 materialized view 流式传输数据的失败尝试次数

ClickHouse 解析失败的 Kafka 消息数

从 librdkafka 轮询并写入 ClickHouse 的 Kafka 消息数量

生成到 Kafka 的消息数

ClickHouse 已处理的 Kafka 消息数

向 Kafka 发送消息时的错误数量

Kafka 生产者执行显式刷写的次数

分区分配数量 (消费者组再平衡的最后阶段)

消费者组再平衡失败次数

被撤销的分区数量 (消费者组再平衡的第一阶段)

从 Kafka 消息中解析的行数

已解析但随后被拒绝的行数 (由于重平衡、错误或类似原因) 。这些行会在重平衡后再次被消费。

写入 Kafka 表的行数

向 Kafka 表写入 (插入) 的次数

添加 watch 的请求数量

达到 max_requests_batch_size 上限的批次数

达到 max_read_batch_size 上限的批次数量

达到 max_read_batch_bytes_size 限制的批次数量

达到 max_requests_batch_bytes_size 限制的批次数

Keeper 更新日志执行 fsync 的耗时 (仅限未压缩日志)

等待获取 Keeper 更新日志锁的耗时

写入 Keeper 更新日志的字节数

检查请求数

remove watches 请求的数量

等待特定日志完成提交所花费的时间

成功提交的次数

失败的提交次数

创建请求数量

exists 请求数量

get 请求数量

Keeper 延迟

递归获取子节点请求数

列表请求数量

等待获取 Keeper 活跃会话锁的时间

Keeper 中从提交日志缓存中读取的日志条目数量

Keeper 中直接从更新日志文件读取的日志条目数

Keeper 中从最新日志缓存中读取的日志条目数

Keeper 中从更新日志文件预取的日志条目数

多重读取请求数量

multi 请求数

Keeper server 收到的数据包

Keeper 服务器已发送的数据包

单个请求的 Keeper 预处理延迟

等待获取 Keeper 处理和响应锁所耗费的时间

单次请求的 Keeper 提交 延迟

Keeper 处理的读取请求批次数

Keeper 按批次处理的读取请求总数

等待获取 Keeper 读取请求队列锁的耗时

已完成的快照读取次数

由于所请求的快照在本地已不可用而被延迟的快照读取次数；NuRaft 将重试最新快照。

快照读取失败次数

发送至跟随者的快照对象数量

重新配置请求数量

删除请求数

移除 watch 的请求数量

因超过软内存限制而被拒绝的请求数量

Keeper server 的请求总数

Keeper server 上的请求总数，会将多重请求中的每个子请求分别计入

保存快照的次数

快照保存失败次数

从 leader 接收到的快照对象数量

等待获取 Keeper server 写锁的耗时

等待获取 Keeper session 回调锁的耗时

Set 请求数

set watches 请求数

应用快照的次数

快照应用失败的次数

快照创建次数

快照创建失败次数

对 Keeper 快照文件执行 fsync 所花费的时间

在向 跟随者 节点提供快照期间，RemoteSnapshotLoader 中发生的远程读取错误数

Keeper 中写入快照文件的字节数

因会话不再存活而被跳过的 Keeper 请求数

等待获取 Keeper 存储锁的时间

等待获取 Keeper 存储共享锁的时间

因队列已满而被丢弃的生存时间 (TTL) 删除请求数

成功加入队列的生存时间 (TTL) 删除请求数

单次请求的 Keeper 总延迟

因子节点变更操作而触发的 watch 次数

由 CREATE 操作触发的 watch 数量

按变更操作统计的 watch 触发次数

由 DELETE 操作触发的 watch 触发次数

watch 被触发的次数

Keeper 处理的写入请求批次数量

Keeper 以批次方式处理的写入请求总数

初始化期间由 MergeTree 表加载的数据分区片段数量。

MergeTree 表在初始化过程中加载数据分区片段所耗费的微秒数。

已加载的标记数量 (所有列合计) 。

已加载的标记文件数。

已加载标记的内存表示大小。

已加载的主键行数。

已加载的主索引文件数。

已加载的主键行数。

加载 parts 中统计信息所耗时间

加载标记的后台任务被取消的次数

经过 max_local_read_bandwidth_for_server/max_local_read_bandwidth 限流器的字节数。

查询因遵循 'max_local_read_bandwidth_for_server'/'max_local_read_bandwidth' 限流而进入休眠状态的总时长。

线程用于执行实际工作的总耗时。

统计为扩展本地线程池而从全局线程池借用线程的总次数。

衡量一个 job 从在线程池中被调度，到被工作线程接手执行之间的耗时。该指标有助于识别 job 处理延迟，反映线程池对新任务的响应速度。

统计已提交到本地线程池的作业数量。

线程在本地线程池中等待锁的总耗时。

统计线程从本地线程池返回至全局线程池的总次数。

本地线程池等待从全局线程池借用线程所花费的总时间。

通过 'max_local_write_bandwidth_for_server'/'max_local_write_bandwidth' 限流器传输的字节数。

查询因受 'max_local_write_bandwidth_for_server'/'max_local_write_bandwidth' 限流而处于休眠状态的总时长。

Debug 级别的日志消息数量

Error 级别的日志消息数量

Fatal 级别的日志消息数量

Info 级别日志消息的数量

Test 级别的日志消息数量

Trace 级别的日志消息数量

警告级别的日志消息数量

日志记录的累计耗时

在 MMap 缓存中命中文件的次数 (针对 mmap 的 read_method) ，因此无需再次对其执行 mmap。

文件在 MMap 缓存中未命中的次数 (针对 'mmap' read_method) ，因此必须再次对其执行 mmap。

主配置被重新加载的次数。

从标记缓存中淘汰的字节数。

从标记缓存中被淘汰的标记文件数量。

从标记缓存中淘汰的标记数量。

在标记缓存中命中条目的次数，因此无需加载标记文件。

条目未在 标记缓存 中命中的次数，因此必须将标记文件加载到内存中；这是一项开销较大的操作，会增加查询延迟。

因标记已存在于缓存中而以同步方式加载标记的次数。

未检查内存约束就分配内存的次数。

未进行内存约束检查时已分配的字节数。

请求进行内存分配器清理的总次数

内存分配器清理耗费的总时间

在 OvercommitTracker 中等待内存释放的总耗时。

查询等待初始内存预留获准的总时间

获批的内存预留减少请求总数

内存预留失败总数

查询等待批准增加内存预留的总时间

获批的内存预留增加请求总数

内存预留终止信号的总数

MemoryWorker 在后台执行的次数

MemoryWorker 执行后台工作的总耗时

已启动的后台合并次数。

提交合并结果 (分片重命名、校验和验证、ZooKeeper 更新) 所花费的总时间

执行后台合并所占用的总忙碌时间

执行后台合并水平阶段所占用的总忙碌时间

后台合并的水平阶段所花费的总时间

在 MergeMutate 执行器 任务中调用 cancel() 所花费的时间。

MergeMutate 执行器 任务执行 executeStep() 所花费的时间。

重置 MergeMutate 执行器任务所花费的时间。

在 MergeMutate 执行器中等待完成的耗时。

执行后台合并预热阶段所占用的总忙碌时间

后台合并预热阶段的总耗时

执行后台合并中的投影阶段所消耗的总忙碌时间

后台合并中投影阶段花费的总时间

计划进行合并的源 parts 数量。

执行后台合并的文本索引阶段所占用的总忙碌时间

后台合并中文本索引阶段花费的总时间

后台合并耗费的总时间

远程服务器向发起端服务器发送的、关于一组数据分区片段 (适用于 MergeTree 表) 的通知数量。此指标在远程服务器端测量。

从远程服务器向发起端服务器发送关于一组数据分区片段 (用于 MergeTree 表) 的通知所耗费的时间。在远程服务器端测量。

INSERT 到 MergeTree 表投影的块数。每个块都会形成一个 0 级数据分区片段。

插入到 MergeTree 表投影中且被判定为已排序的块数量。

将插入到 MergeTree 表投影中的数据写入文件系统的字节数。

合并块所耗费的时间

INSERT 到 MergeTree 表投影的行数。

块排序耗时 (对于投影，其键可能与表的排序键不同)

插入到 MergeTree 表投影中的未压缩字节数 (按列在内存中的存储形式计算) 。

向 MergeTree 表中 INSERT 的块数量。每个块都会形成一个级别为零的数据分区片段。

INSERT 到 MergeTree 表中且似乎已排序好的块数。

将插入到 MergeTree 表中的数据写入文件系统的字节数。

合并输入块所耗费的时间 (适用于特殊的 MergeTree 引擎)

计算 投影 所花费的时间

插入到 MergeTree 表中的行数。

计算跳过索引所花费的时间

块排序耗时

计算统计信息的耗时

插入到 MergeTree 表中的未压缩字节数 (按列在内存中的存储形式计算) 。

准备 MergeTreePrefetchedReadPool 中任务所花费的时间

从远程服务器回传到发起端服务器、用于选择读取任务 (针对 MergeTree 表) 的回调请求数。在发起端服务器侧计量。

为选择读取任务，远程服务器向发起端服务器请求的回调次数 (针对 MergeTree 表) 。在远程服务器端测量。

远程服务器向发起端服务器请求回调以选择读取任务所耗费的时间 (适用于 MergeTree 表) 。在远程服务器端测量。

后台合并垂直阶段执行所占用的总忙碌时间

后台合并纵向阶段耗费的总时间

合并期间写入的行数。

在合并操作的水平阶段中被合并的列数。

被合并为 Compact 格式的 parts 数量。

合并为 Wide 格式的 parts 的数量。

在 MergeTree 合并过程中被合并 (而非重建) 的投影数量。

后台合并读取的行数。这是合并前的行数。

后台合并读取的未压缩字节数 (按列在内存中的存储形式计算) 。这是合并前的数值。

可供 合并 的候选 parts 数量

根据合并谓词准备可进行合并的 parts 范围所花费的时间。

用于合并的候选范围数量

从各个范围中选择可合并 parts 所花费的时间。

所选合并范围内的 parts 数量

获取数据分区片段快照并基于其构建范围所花费的时间。

因内存限制而被拒绝的后台合并次数

通过 'max_merges_bandwidth_for_server' 限流器的字节数。

查询因遵守 'max_merges_bandwidth_for_server' 限流而休眠的总时长。

合并已排序列所耗费的总时间

由后台任务清理空 blob layout 分片的次数

后台清理任务中发生错误的次数

后台任务执行清理已删除旧对象的次数

后台任务清理旧事务幂等令牌的次数

对象存储元数据请求在未向 Keeper 发起请求的情况下直接由缓存响应的次数

对象存储元数据请求需由 Keeper 返回结果的次数

文件系统缓存返回过多无效条目的次数

更新缓存 (包括等待 Keeper 响应) 所耗费的总时间

尝试执行已删除对象清理的元数据事务提交的次数

已删除对象清理过程中元数据事务提交的重试次数

对 Keeper 发起的单次或批量请求中读取或写入的路径数量

向 Keeper 发起单个或多个请求期间的耗时

向 Keeper 发起请求的次数

重连 Keeper 的次数

元数据事务提交的尝试次数

元数据事务提交重试次数

目录树某一层级的缓存更新次数

Move 执行器 任务在 cancel() 中耗费的时间。

在 Move 执行器任务中执行 executeStep() 所花费的时间。

重置 Move 执行器任务所花费的时间。

在 Move 执行器中等待完成所耗费的时间。

在变更中计算投影所花费的时间

为变更操作读取的行数。表示变更前的行数

为变更而读取的未压缩字节数 (指列以存储在内存中时的形式计算) 。这是变更前的数值。

受变更影响的行数上限 (例如，满足 UPDATE 或 DELETE 变更谓词的行数) 。实际数量可能略少

创建对分片中所有列执行变更任务的次数

提交变更结果 (分片重命名、校验和校验、ZooKeeper 更新) 花费的总时间

未执行变更、而是被替换为空 parts 的 parts 总数

执行变更所占用的总忙碌时间。

创建用于对分片中部分列执行变更的任务的次数

变更耗费的总时间。

尝试应用变更的 parts 总数

尝试应用变更但因 predicate 而被完全跳过的 parts 总数

所有读取任务中实时应用的变更总数

经 'max_mutations_bandwidth_for_server' 限流器传输的字节数。

查询为遵循 max_mutations_bandwidth_for_server 限流而休眠的总时长。

朴素贝叶斯分类器模型已分配的字节数。

已加载的朴素贝叶斯分类器模型数。

从网络接收的总字节数。仅统计与 ClickHouse 相关的网络通信，不包括第三方库产生的网络交互。

等待接收数据或从网络接收数据所耗费的总时间。仅包含与 ClickHouse 相关的网络交互，不包括由第三方库产生的交互。

通过网络发送的总字节数。仅统计与 ClickHouse 相关的网络交互，不包括第三方库产生的网络交互。

等待将数据发送到网络或通过网络发送数据所耗费的总时间。仅包括与 ClickHouse 相关的网络交互，不包括第三方库产生的网络交互。

由于另一个副本并发更新了日志，ReplicatedMergeTree 中用于合并 parts 的日志条目未能创建。

由于另一副本并发更新日志，未能创建用于对 ReplicatedMergeTree 中 parts 执行变更的日志条目。

操作系统可见的 CPU 已用时间。不包括因虚拟化而产生的非自愿等待。

从操作系统的角度看，线程已准备执行但仍在等待操作系统调度的总时间。

从操作系统的角度来看，线程等待 IO 操作结果所耗费的总时间。这是真实的 IO，不包括页缓存。

从磁盘或块设备读取的字节数。不包括从页缓存中读取的字节。由于块大小、预读等因素，实际读取的数据量可能会偏大。

从文件系统 (包括页缓存) 、网络及其他文件中读取的字节数。

写入磁盘或块设备的字节数。不包括页缓存中脏页里的字节。也可能不包括由操作系统异步写入的数据。

写入文件系统的字节数，包括 page cache，以及网络和其他文件。

未匹配 glob 或 regex 模式、因此在列出时被跳过的对象。

应用任何过滤器之前，对象存储列出 API 返回的对象总数。

因对 _path/_file 应用虚拟列谓词过滤而被排除的对象。

StorageS3(Azure)Queue 中被取消的文件数量

将文件标记为失败所花费的时间

将文件提交为 failed 或 processed 状态的 Keeper 请求数

S3(Azure)Queue 中插入时发生的异常数量

S3(Azure)Queue 读取期间发生的异常数量

处理失败的文件数

将对象批量设置为处理中状态的请求失败次数

StorageS3(Azure)Queue 中被过滤的文件数

插入迭代次数

StorageS3(Azure)Queue 中列出的文件数量

设置 after_processing = move 后被移动的对象数量

已处理文件数量

StorageS3(Azure)Queue 中已处理行数

读取文件数据耗费的时间

读取的字节数 (不等于实际插入的字节数)

读取的文件数 (不等于实际插入的文件数)

读取的行数 (不等于实际插入的行数)

因 after_processing = delete 而被删除的对象数量

成功的 Keeper 提交数

被标记为 after_processing = tag 的对象数

将文件设为处理中状态失败的次数

尝试发起将对象设为处理中状态的请求次数

成功将文件标记为处理中状态的次数

Keeper 提交失败次数

对象存储源中实际打开并读取的对象数。

数据分区片段被另一个从副本拉取的数据分区片段覆盖的次数 (即我们会将被覆盖的数据分区片段标记为已废弃，不再需要) 。

在已打开的文件缓存中命中文件的次数，因此无需再次打开该文件。

执行 OpenedFileCache 方法所耗费的时间。

文件在已打开的文件缓存中未命中，因此不得不再次打开它的次数。

非 SELECT 或 INSERT 类型查询的总耗时。

近似 GROUP BY 生效的次数：当聚合只对前 'max_rows_to_group_by' 个唯一键进行，而由于 'group_by_overflow_mode' = 'any'，其余键被忽略时。

由于查询复杂度限制且设置了 '*_overflow_mode' = 'break'，数据处理被中止并导致结果不完整的次数。

设置 '*_overflow_mode' = 'throw' 时，因达到查询复杂度限制而取消数据处理并抛出异常的次数。

数据块在用户态页缓存中命中的次数。

数据块在用户态页缓存中未命中的次数。

内存分配过程中，为释放内存而自动调整用户态页缓存大小的次数。

从用户态页缓存中读取的字节数。

用户态页缓存自动调整大小的次数 (通常每秒会发生几次，由 memory_worker_period_ms 控制) 。

从用户态页缓存中被逐出的字节数

发送通知耗费的时间

使用基于任务的并行副本执行查询时可用的副本数

收集按哈希归属的分段所花费的时间

发往发起节点且被完全拒绝的请求数

处理副本通知所用的时间

处理来自副本的标记请求所用的时间

发送到发起节点的请求数。

处理数据分区片段耗时

一次查询执行过程中使用并行副本执行的 (子) 查询数

所有副本中，通过一致性哈希分配给工作窃取的已调度标记数量总和

所有副本中通过一致性哈希分配的已调度标记总数

给定副本读取的标记数

读取请求耗时

所有副本中已调度的未分配标记总数

按哈希收集待窃取分段所耗费的时间

收集遗留分段所用的时间

在基于任务的并行副本查询执行期间，已被选中但随后发现不可用的副本数量

使用基于任务的并行副本执行查询时使用的副本数

经过过滤器的列总数

由 Parquet 读取器提交到线程池的任务组

由 Parquet 读取器 发起的任务

解码线程读取 Parquet 文件时的等待时间 (不包括预取线程)

在缓存中命中 Parquet 元数据的次数。

未在缓存中命中 Parquet 元数据、因此必须从磁盘读取的次数。

从 Parquet 元数据缓存中逐出的字节数估计值。

DB::Parquet::Prefetcher 以 ReadMode::EntireFileIsInMemory 模式读取的总次数

DB::Parquet::Prefetcher 使用 ReadMode::RandomRead 的读取总次数

DB::Parquet::Prefetcher 以 ReadMode::SeekAndRead 模式进行读取的总次数

从 Parquet 数据中剪枝掉的行组总数

从 Parquet 数据中读取的行组总数

经过过滤器的总行数

在 MergeTree 表中持有数据分区片段锁所花费的总时间

在 MergeTree 表中等待数据分区片段锁的总时间

MergeTree 表的数据分区片段锁获取次数

执行轻量级更新时获取锁所花费的总微秒数

执行轻量级更新时尝试获取锁的总次数

全部读取任务中已应用的补丁分区片段总数

在所有读任务中以 Join 模式应用的补丁分区片段总数

以 Join 模式应用补丁分区片段时加入哈希表的总行数

所有读取任务中以 Merge 模式应用的补丁分区片段总数

从补丁分区片段读取的总行数

从补丁分区片段中读取的未压缩字节总数

对齐故障次数。当发生未对齐的内存访问时，就会出现这类故障；内核虽然可以处理，但会降低性能。此问题只会出现在某些架构上 (x86 上不会出现) 。

已执行的分支指令。在 Linux 2.6.35 之前，这在 AMD 处理器上使用的是错误的事件。

被错误预测的分支指令。

总线周期，可能不同于总周期。

CPU 时钟，一种高分辨率的按 CPU 计时器

总周期数。请留意 CPU 频率调整时带来的影响。

进程迁移到其他 CPU 的次数

缓存未命中。通常表示最后一级缓存 (Last Level Cache) 未命中；该指标通常与 PERFCOUNTHWCACHEREFERENCES 事件配合使用，以计算缓存未命中率。

缓存访问次数。通常，这表示最后一级缓存 (Last Level Cache) 的访问次数，但具体含义可能因 CPU 而异。其中也可能包括预取和一致性消息；同样，这取决于 CPU 的设计。

上下文切换次数

数据 TLB 未命中

数据 TLB 引用次数

仿真故障次数。内核有时会在遇到未实现的指令时触发陷阱，并在用户空间中对其进行仿真。这可能会对性能造成负面影响。

指令 TLB 未命中

指令 TLB 访问

已退休指令数。请注意，该计数可能会受到多种因素影响，其中最明显的是硬件中断计数。

本地 NUMA 节点内存读取未命中次数

本地 NUMA 节点内存读操作

启用时间最短的事件的运行时间。用于跟踪事件多路复用的程度

对于所有事件，事件处于启用状态的最小时间。用于跟踪事件复用的影响

总周期数；不受 CPU 频率变化影响。

指令退休期间发生停滞的周期数。

指令发射阶段的停滞周期。

当前正在运行任务对应的时钟计数

参见设置 prefer_warmed_unmerged_parts_seconds。读取查询未使用尚未被 CacheWarmer 拉入缓存的 merged part，而是使用缓存中过期的、合并前的 parts 的次数。

在主索引缓存中命中条目的次数，因此无需加载索引文件。

主索引缓存未命中条目的次数，因此不得不将索引文件加载到内存中；这是一项代价高昂的操作，会增加查询延迟。

统计包含其所有子查询的查询数量

被解释并可能执行的查询数量。不包括解析失败的查询，也不包括因 AST 大小限制、配额限制或同时运行的查询数量限制而被拒绝的查询。可能包括由 ClickHouse 自身发起的内部查询。不包括子查询。

构建查询树并运行 analyzer 各阶段 (解析标识符、类型和表达式) 所花费的总时间。

通过 'max_backup_bandwidth' 限流器的字节数。

查询为满足 max_backup_bandwidth 限流要求而休眠的总时长。

找到的查询缓存条目的总存续时间 (以秒为单位) 。无论命中还是未命中，都会设置该值。

查询结果在查询缓存中命中的次数 (从而避免了查询计算) 。仅对设置了 use_query_cache = 1 的 SELECT 查询更新。

查询结果在查询缓存中未命中的次数 (因此需要重新计算查询) 。仅针对使用 SETTING use_query_cache = 1 的 SELECT 查询更新。

从查询缓存读取的 (未压缩) 字节数。

从查询缓存读取的行数。

写入查询缓存的 (未压缩) 字节数

写入查询缓存的行数。

在查询条件缓存中命中某个条目的次数 (因此可跳过读取标记) 。仅对设置了 SETTING use_query_condition_cache = 1 的 SELECT 查询更新。

在查询条件缓存中未命中条目的次数 (因此无法跳过读取标记) 。仅对设置了 SETTING use_query_condition_cache = 1 的 SELECT 查询进行更新。

通过 max_local_read_bandwidth 限流器的字节数。

查询因受 max_local_read_bandwidth 限流而进入休眠的总时长。

通过 max_local_write_bandwidth 限流器的字节数。

查询为遵守 max_local_write_bandwidth 限流而休眠的总时长。

查询脱敏规则成功匹配的次数。

查询超过内存限制的次数。

将查询文本解析为 AST 所耗费的总时间。

从优化后的 QueryPlan 构建 QueryPipeline 所花费的总时间。

基于已分析的查询树构建 QueryPlan 所耗费的总时间。

执行查询计划优化所耗费的总时间。

因 priority 设置而被暂停并处于等待状态的任务次数

由于其他线程中并发运行的 query profiler 过多，我们丢弃 query profiler 信号处理的次数，这可能表明系统已过载。

在异步栈展开过程中发生的无效内存访问。

QueryProfiler 的运行次数。

因超限而丢弃 query profiler 信号处理的次数，加上操作系统因超限而未传递的信号次数。

经过 'max_remote_read_network_bandwidth' 限流器的字节数。

查询因受 max_remote_read_network_bandwidth 限流而进入休眠状态的总时长。

经过 max_remote_write_network_bandwidth 限流器的字节数。

查询因受 'max_remote_write_network_bandwidth' 限流而处于休眠状态的总时长。

所有查询耗费的总时间。

因未达到 quorum 而失败的插入次数。

通过 quorum 写入的数据分区片段数量。对于同步插入，计为 1 个数据分区片段；对于触发异步插入刷写的插入操作，最多可能计为与异步插入次数相同的数量。

插入操作期间等待 quorum 的总耗时。

为所有当前存活且已启用的集合重新选择配额所花费的总时间 (该过程在 cache mutex 的保护下进行，ContextAccess 的 build 路径也会获取这个 mutex) 。

配额缓存为所有当前生效且已启用的集合重新选择配额的次数。按访问实体通知批次合并后，每个批次只计一次。

在 heavy RWLock 中获取读锁的次数。

获取到写锁的次数 (在 heavy RWLock 中) 。

在 heavy RWLock 中等待获取读锁所花费的总时间。

在 heavy RWLock 中，等待获取写锁所耗费的总时间。

因读取速度过慢而下调查询处理线程数的次数。

从 Azure 读取的字节数。

初始化与 Azure 的连接所用的时间。

从 Azure 读取数据所耗费的时间。

从 Azure 读取时发生的异常次数

从文件描述符读取 (read/pread) 的次数。不包括套接字。

从文件描述符读取的字节数。如果文件已压缩，此处显示的是压缩后数据的大小。

从文件描述符读取 (read/pread) 失败的次数总计。

从 S3 读取的字节数。

初始化与 S3 的连接所花费的时间。

从 S3 读取耗费的时间。

从 S3 读取时发生的异常次数。

导致建立新连接的寻道次数 (S3、HTTP)

从压缩源 (文件、网络) 读取的字节数 (即解压前的字节数) 。

读取补丁分区片段耗费的总时间

从远程服务器回传到发起端服务器、用于选择读取任务的回调请求数量 (适用于 s3Cluster 表函数及类似场景) 。在发起端服务器侧测量。

远程服务器向发起服务器请求回调、以选择读取任务的次数 (适用于 s3Cluster 表函数及类似功能) 。该指标在远程服务器端统计。

远程服务器向发起端服务器请求回调以选择读取任务所花费的时间 (用于 s3Cluster 表函数及类似功能) 。在远程服务器端测量。

在读取过程中应用了变更的读取任务总数

应用过任何 patch part 的读取任务总数

由 ReadWriteBufferFromHTTP 接收和发送的载荷总字节数。不包括 HTTP 请求头。

ReadWriteBufferFromHTTP 发出的 HTTP 请求数

在所有缓存层级都未命中后 (包括前台读取和后台预取，也包括后来被丢弃而浪费掉的预取字节) ，ReaderExecutor 向源端发出的物理字节数；不包含由消费者提供的字节数——参见 ReaderExecutorRequestedBytes。

ReaderExecutor 中 ICacheHandle::get 的调用次数。在引入 ReaderExecutor 缓存层级之前，该值为零。

ReaderExecutor 中 ICacheHandle::put 的调用次数。在引入 ReaderExecutor 缓存层级之前，该值始终为 0。

ReaderExecutor 在将源连接排空到其右边界之前丢弃的源连接数量；这些连接无法回收到池中复用，因此必须重新建立。在引入 ReaderExecutor 的在线源缓冲区复用之前，该值始终为零。

ReaderExecutor 读取操作的建模 I/O 成本：这是一个用于衡量读取路径优化程度的合成代理 KPI，并非实测延迟。它是上述计数器按启发式 S3 权重计算得出的加权总和：每个源请求 30ms + 每个未完成连接 5ms + 每个从源端传输的 MiB 20ms (包括有效载荷和过度读取) + 每次 cache put 0.1ms + 每次 cache get 0.05ms。再除以 ReaderExecutorRequestedBytes，即可得到不受负载影响的单位字节成本。Experimental，用于跟踪 Experimental 状态的 ReaderExecutor。

ReaderExecutor 向读取请求提供的有效字节数 (即请求的 window 载荷，不包括额外读取和缓存回写) 。它是建模的每字节成本 KPI (ReaderExecutorModeledCostMicroseconds / ReaderExecutorRequestedBytes) 的分母。

ReaderExecutor 打开的源侧请求数量 (不包括实时缓冲区复用) 。

在 ReaderExecutor::readNextWindow 中花费的总挂钟时间 (包括打开、寻道和读取所处理的窗口) 。会直接影响查询读取延迟。

处理线程 (执行查询及其他任务) 消耗的总时间 (墙钟时间，注意这是累加值) 。

在 MergeTree 合并过程中从头开始重建的投影数。

由于旧表被删除，从可刷新materialized view 执行 SELECT 时不得不切换到新表的次数

可刷新materialized view 刷新失败的次数

可刷新materialized view 的刷新次数

从可刷新materialized view 执行 SELECT 失败后，重试隐式 SYNC REPLICA 的次数

从可刷新materialized view 执行 SELECT 时隐式触发 SYNC REPLICA 的次数

从本地缓存中获取已编译正则表达式的次数。

未能从本地缓存中获取已编译正则表达式的次数。

已编译包含多模式串的正则表达式 (VectorScan 库) 。

从全局缓存中拉取已编译的多模式串正则表达式 (VectorScan 库) 的次数。

无法从全局缓存中获取已编译的多模式串正则表达式 (VectorScan 库) 的次数。

由于分区中的活动数据分区片段过多，向 MergeTree 表 INSERT 一个块时因出现“parts 过多”异常而被拒绝的次数。

因 patches 中未压缩字节过多而被拒绝的轻量级更新次数。

由于表中未完成的变更过多，MergeTree 表的变更因出现“Too many mutations”异常而被拒绝的次数。

为异步读取远程文件系统而创建的缓冲区数量

因寻道而取消的预取次数

惰性寻道次数

预取缓冲区中的字节数

从预取缓冲区读取的次数

异步读取远程文件系统时的预取次数

异步缓冲区寻道总次数

导致建立新连接的寻道次数

未预取缓冲区中的字节数

从未预取缓冲区读取的次数

缓冲区销毁时仍处于待处理状态的预取次数

通过 'max_remote_read_network_bandwidth_for_server'/'max_remote_read_network_bandwidth' 限流器传输的字节数。

查询为符合 max_remote_read_network_bandwidth_for_server/max_remote_read_network_bandwidth 限流要求而休眠的总时长。

经由 'max_remote_write_network_bandwidth_for_server'/'max_remote_write_network_bandwidth' 限流器的字节数。

查询因遵循 'max_remote_write_network_bandwidth_for_server'/'max_remote_write_network_bandwidth' 限流而休眠的总时长。

替换已排序列耗费的总时间

Replicated 表因 ZooKeeper 中的会话过期而不得不反初始化其状态的次数。每当 ZooKeeper 恢复可用时，都会重新初始化该状态。

用于调试。ZooKeeper 中存在覆盖 part、但磁盘上不存在的 parts 数量。在服务器启动时检查。

所需数据分区片段在任何副本上都不存在 (包括当前离线的副本) 时的次数。这些数据分区片段可以确定已经丢失。在异步复制场景下，这属于正常现象 (如果未启用 quorum 插入) ：当写入该数据分区片段的副本发生故障，并在故障后重新上线时，它将不会包含该数据分区片段。

为了在副本上查找某个数据分区片段，或确认是否需要某个现有数据分区片段而必须执行高级搜索的次数。

在副本上对数据分区片段进行高级搜索但未找到结果，或发现异常的数据分区片段并将其移走的次数。

从 ReplicatedMergeTree 表的副本拉取数据分区片段失败的次数。

从 ReplicatedMergeTree 表的副本拉取数据分区片段的次数。

表示我们选择从 ReplicatedMergeTree 表的副本拉取已合并的数据分区片段、而不是自行执行合并的次数 (通常为了节省网络流量，我们更倾向于自行合并) 。出现这种情况通常是因为我们缺少执行合并所需的全部源 parts，或者该数据分区片段已经足够旧。

ReplicatedMergeTree 表中的数据分区片段成功合并的次数。

ReplicatedMergeTree 表中的数据分区片段成功完成变更的次数。

恢复 parts 时被跳过的文件总大小

恢复 parts 过程中跳过的文件数

重新计算所有当前生效的活动 角色 集合所耗费的总时间 (在持有缓存 互斥锁 的情况下，ContextAccess 的构建路径也会获取该 互斥锁) 。

角色缓存重新计算所有当前生效的已启用集合的次数。每个访问实体通知批次最多只会合并为一次。

为所有当前生效且已启用的集合重新组合行策略过滤器所花费的总时间 (在持有缓存互斥锁期间进行，ContextAccess 的构建路径也会获取该互斥锁) 。

行策略缓存为所有当前有效且已启用的集合重新组合过滤器的次数。按访问实体通知批次合并计算，每个批次最多一次。

主读取器从 MergeTree 表中读取的行数 (在 PREWHERE 步骤之后) 。

prewhere 读取器从 MergeTree 表中总共读取的行数。

统计信息：如果查询以并行副本方式执行，各副本将读取的字节数

统计在使用并行副本执行查询时，副本将发送给发起节点的字节数

经 JOIN 运行时过滤器 处理的块数

由于过滤效果较差，过滤器被动态禁用，因此 JOIN 运行时过滤器 未经处理而跳过的块数

经 JOIN 运行时过滤器 检查的行数

通过 JOIN 运行时过滤器的行数 (即未被其过滤掉)

因 JOIN 运行时过滤器 而被跳过的块中的行数

单次查询中创建的不同 JOIN 运行时过滤器 数量

S3 API AbortMultipartUpload 调用次数。

添加到缓存中的新凭证提供商总数

从缓存中复用的凭证提供程序总数

已创建的 S3 客户端数。

S3 API CompleteMultipartUpload 的调用次数。

S3 API 的 CopyObject 调用次数。

S3 API 的 CreateMultipartUpload 调用次数。

S3 API DeleteObject(s) 的调用次数。

S3 API GetObject 调用的次数。

S3 API 的 GetObjectTagging 调用次数。

被限流器拦截的 S3 GET 和 SELECT 请求数。

经过限流器的 S3 GET 和 SELECT 请求数：包括被阻止和未被阻止的请求。

查询为满足 S3 GET 和 SELECT 请求限流要求而休眠的总时长。

S3 API HeadObject 调用的次数。

S3 API 的 ListObjects 调用次数。

S3 API 的 PutObject 调用次数。

被限流器拦截的 S3 PUT、COPY、POST 和 LIST 请求数。

通过限流器的 S3 PUT、COPY、POST 和 LIST 请求数量：包括被阻止和未被阻止的请求。

查询因遵守 S3 PUT、COPY、POST 和 LIST 请求限流而休眠的总时长。

将文件设置为失败状态所花费的时间

将文件设为已处理状态所花费的时间

将文件设为处理中状态所花费的时间

对 S3 存储发起 GET 和 HEAD 请求所耗费的时间。

GET 和 HEAD 请求的尝试次数，包括首次尝试和任何重试，但不包括由 S3 重试策略在内部执行的重试

GET 和 HEAD 请求中可重试错误的数量，不包括由 S3 重试策略在内部执行的重试

发往 S3 存储的 GET 和 HEAD 请求数。

S3 存储的 GET 和 HEAD 请求中的非限流错误数。

对 S3 存储发起的 GET 和 HEAD 请求中的重定向次数。

对 S3 存储执行 GET 和 HEAD 请求时出现的 429 和 503 错误数量。

S3 API UploadPart 调用的次数。

S3 API UploadPartCopy 调用次数。

向 S3 存储发送 POST、DELETE、PUT 和 PATCH 请求所花费的时间。

POST、DELETE、PUT 和 PATCH 请求的尝试总次数，包括首次尝试和任何重试，但不包括由重试策略在内部执行的重试

POST、DELETE、PUT 和 PATCH 请求中可重试错误的数量，不包括由重试策略内部执行的重试

向 S3 存储发出的 POST、DELETE、PUT 和 PATCH 请求数。

向 S3 存储发出的 POST、DELETE、PUT 和 PATCH 请求中，非限流错误的数量。

对 S3 存储发起的 POST、DELETE、PUT 和 PATCH 请求的重定向次数。

向 S3 存储发起 POST、DELETE、PUT 和 PATCH 请求时返回的 429 和 503 错误数。

从标量子查询读取时缓存未命中，因此必须完整计算的次数

使用全局缓存读取标量子查询的次数

从标量子查询读取并使用本地缓存的次数

经由调度器进行 IO 读取的字节数。

经调度器处理的 IO 读请求资源请求。

查询因等待 IO 读取资源请求而花费的总时间。

通过调度器执行 IO 写入时传输的字节数。

经由调度器传递的 IO 写入资源请求。

查询等待 IO 写入资源请求的总时长。

缓存中的 schema 因溢出而被淘汰的次数

在 schema 缓存中命中所请求 source 的次数

因数据发生变化而导致缓存中的 schema 失效的次数

请求的数据源未命中 schema 缓存的次数

从文件统计时，在 schema 缓存中命中行数的次数

请求的源已在缓存中，但从文件进行计数时，行数不在缓存中的次数

schema 推断 期间在 schema 缓存中找到 schema 的次数

schema 推断期间，请求的 source 在缓存中但 schema 不在缓存中的次数

调用 'lseek' 函数的次数。

统计使用主键来判断 WHERE 条件的 SELECT 查询数量

统计 SELECT 查询及其所有子查询的数量

与 Query 相同，但仅用于 SELECT 查询。

SELECT 查询的总耗时。

从所有表中 SELECT 的字节数 (未压缩；对于列，按其在内存中的存储形式计算) 。

从 MergeTree 表中选择读取的标记数 (索引粒度) 。

在从 MergeTree 表中确定要读取哪些标记之前的标记总数 (索引粒度) 。

从 MergeTree 表中选取并读取的数据分区片段数量。

在从 MergeTree 表中选择要读取哪些数据分区片段之前，数据分区片段的总数。

从 MergeTree 表中选中读取的所有数据分区片段中 (非相邻) 区间的数量。

从所有表中 SELECT 的行数。

插入到 ReplicatedMergeTree 表的块中，被系统自行去重的异步插入数量。

从服务器启动到开始监听套接字的耗时 (以毫秒为单位)

为所有当前生效且已启用的集合重新合并设置和约束所耗费的总时间 (在持有 cache 互斥锁 期间，ContextAccess 的 build 路径也会获取该 互斥锁) 。

settings profile 缓存在为所有当前活动且已启用的集合重新合并设置和约束时的次数。每个访问实体通知批次合并计为一次。

查询中涉及的分片数量，按所有分布式表和表函数汇总计算。如果同一主机出现在多个表中，则会被重复计数。该数值表示预期的分片总数，其中也包括在 skip_unavailable_shards 设置下被跳过的分片。

SharedDatabaseCatalog 中应用新状态失败的次数

在 SharedDatabaseCatalog 中应用新状态的总耗时

用于移除废弃 parts 的 ZooKeeper 请求数

因冲突而未能获取锁的次数

已移除的废弃 parts 数量

尝试拉取数据分区片段的次数

从 peer 拉取数据分区片段的次数

从 peer 拉取数据分区片段耗时 (微秒)

从 S3 拉取数据分区片段的次数

scheduleDataProcessingJob 中要处理的阻塞 parts 数量

在 scheduleDataProcessingJob 中处理阻塞的 parts 所花费的时间

在 scheduleDataProcessingJob 中处理已拉取 parts 所花费的时间

在 scheduleDataProcessingJob 中处理的过期分区片段数量

在 scheduleDataProcessingJob 中处理过期分区片段所用的时间

仅 SharedMergeTree 的 loadColumnsChecksumsIndexes 耗时

尝试分配合并或变更任务的次数

因 Keeper 中发生冲突而导致分配 merge 或变更失败的次数

尝试分配合并或变更任务但因没有可合并内容而失败的次数

尝试分配合并或变更任务的次数

移至废弃目录的 parts 数量

被移动到过期目录的 parts 数量

SMT 的合并选择任务耗时 (微秒)

未访问 Keeper 即命中元数据缓存提示的次数

已执行的异步 OPTIMIZE 查询

已执行同步 OPTIMIZE 查询

确认过期分区片段的调用次数

用于配置过期分区片段时使用的 ZooKeeper 请求数

为确认过期分区片段而发送的 HTTP 请求数量

为确认过期分区片段而发送的 HTTP 响应数量

因并发变更而不得不重试 Keeper 多重写入的分区级操作 (DROP/MOVE/REPLACE/CLONE/TRUNCATE PARTITION) 次数

parts killer 主线程耗费的时间

killer 已调度的 parts 数量

移除 parts 需要多长时间 (由多个线程执行)

parts killer 的运行次数

updateReplicaSetTask 运行的次数

从 ZooKeeper 更新副本集的次数

更新副本集所花费的时间

为更新副本集而发起的 ZooKeeper 请求总数

scheduleDataProcessingJob 被调用的次数/

scheduleDataProcessingJob 的执行时间

scheduleDataProcessingJob 被调用但没有可执行操作的次数

selectPartsForCoordinatedFetch 耗时

被 selectPartsForCoordinatedFetch 选中的 parts 数量

selectPartsForFullFetch 的耗时

被 selectPartsForFullFetch 选中的 parts 数量

selectPartsForRendezvousFetch 的耗时

selectPartsForRendezvousFetch 选中的 parts 数量

SnapshotCleanerThread 决定清理某个 part 的次数

SnapshotCleanerThread 已运行多长时间

SnapshotCleanerThread 尝试清理一个 part 所需的时间

SnapshotCleanerThread 清理 parts 所需的时间

SnapshotCleanerThread 的运行次数

SnapshotCleanerThread 成功清理 part 的次数

在 scheduleDataProcessingJob 中 tryUpdateDiskMetadataCacheForPart 的耗时

虚拟分区片段更新 (微秒)

虚拟分区片段更新次数

按 leader 统计的虚拟分区片段更新

由非默认后台作业触发的虚拟分区片段更新

来自对等节点的虚拟分区片段更新次数

来自对等节点的虚拟分区片段更新时间 (微秒)

来自 ZooKeeper 的虚拟分区片段更新次数

来自 ZooKeeper 的虚拟分区片段更新耗时 (微秒)

虚拟分区片段更新 leader 选举失败

虚拟分区片段更新 leader 成功选出

来自对等节点的虚拟更新失败，因为未找到任何对等节点

在 MergeTree 表中持有共享数据分区片段锁的总耗时

等待 MergeTree 表中共享数据分区片段锁的总耗时

MergeTree 表中共享数据分区片段锁的获取次数

调用 sleep 函数 (sleep、sleepEachRow) 的次数。

在 sleep 函数 (sleep、sleepEachRow) 中休眠耗费的时间。

在 sleep 函数 (sleep、sleepEachRow) 中设置的睡眠时长。

从文件读取时发生慢读的次数。这表明系统负载过高。阈值由 read_backoff_* 设置控制。

查询执行线程中的软缺页次数。软缺页通常表示内存分配器缓存未命中，因此需要操作系统创建新的内存映射，并随后分配一个物理内存页。

Buffer 表中的缓冲区因写入目标表时出错而无法刷新的次数。

Buffer 表中缓冲区刷写到存储的次数。

读取时等待 Buffer 层的时间。

等待空闲 Buffer 层 以执行写入的时间 (可用于调优 Buffer 层) 。

在 'Buffer' 表中，达到所有最小阈值条件并触发缓冲区刷新的次数。

在 'Buffer' 表中，为刷新缓冲区而达到仅后台按字节数计算的刷写阈值的次数。这是仅限专家使用的指标。如果你读到这里，但并非专家，请停止阅读。

在 'Buffer' 表中，为刷新缓冲区而达到最大字节阈值的次数。

在 'Buffer' 表中，为刷写缓冲区而达到仅在后台生效的行数 刷写阈值 的次数。这是一个仅供专家使用的指标。如果你看到这里但并非专家，请停止阅读。

在 'Buffer' 表中，因达到最大行数阈值而触发缓冲区刷写的次数。

在“Buffer”表中，仅在后台执行且基于时间的 刷写阈值 达到时触发缓冲区 flush 的次数。这是仅供专家使用的指标。如果你看到这段说明但并非专家，请停止阅读。

在 'Buffer' 表中，因达到最大时间阈值而触发缓冲区刷写的次数。

已创建的存储连接数

创建存储连接的总耗时

为存储创建连接失败的次数

存储后端的过期连接数

为存储保留的连接数

存储连接被重置的次数

各存储后端的复用连接数

对已排序列求和所花费的总时间

启用 async_query_sending_for_remote 时，向分片发送查询被暂停的总次数。

异步本地读取中等待同步读取所耗费的时间。

等待同步远程读取的耗时。

任一系统日志未能刷新到对应系统表的次数。系统会重复尝试刷新。

用于处理查询及其他任务的线程在操作系统内核模式下执行 CPU 指令所耗费的总时间。即花费在系统调用上的时间，不包括阻塞式系统调用期间的等待时间。

表函数调用次数。

添加了从文本索引直接读取提示、但因选择性低而被丢弃的索引粒度数量。

文本索引中，基于模式的字典扫描因待读取的倒排列表数量超过阈值而被放弃的次数。

请求头在缓存中的命中次数。

请求头在缓存中未命中的次数。

惰性倒排列表模式下执行的推进操作次数。

在惰性倒排列表模式下，由于输出区域已确定 (对于 OR 为全 1，对于 AND 为全 0) 而被跳过的 打包块 数量。

在惰性倒排列表模式下执行的穷举求交次数。

在惰性倒排列表模式下进行的 leapfrog 求交次数。

惰性倒排列表模式下已解码的打包块数量。

在惰性倒排列表模式下，实际被读取并解码的分段数量 (缓存未命中) 。

在惰性倒排列表模式下，已准备的分段数量 (从磁盘读取或已缓存) 。

在惰性倒排列表模式下，未解码块、而是按整体进行填充 (OR 使用 memset，AND 使用 increment) 的完全稠密分段数量。

在惰性倒排列表模式下，由于输出区域已确定 (OR 为全 1，AND 为全 0) 而跳过的分段数量。

在 roaringish 短语匹配求交过程中耗费的总时间。

用于短语搜索的文本索引位置列表 (.pos) 解码所耗费的总时间。

文本索引倒排列表在缓存中命中的次数。

文本索引倒排列表在缓存中未命中的次数。

从磁盘读取文本索引字典块的次数。

读取并分析文本索引粒度的总耗时。

从文本索引读取倒排列表的次数。

从文本索引读取稀疏索引块的次数。

读取文本索引花费的总时间。

文本索引标记信息在缓存中命中的次数。

文本索引标记信息在缓存中未命中的次数。

已添加“直接从文本索引读取”提示且实际使用了该提示的索引粒度数量。

字典中嵌入的倒排列表被使用的次数。

ThreadPoolReader 内部读取命中页缓存的次数。

ThreadPoolReader 命中页缓存时读取的字节数。

ThreadPoolReader 从 页缓存 读取数据所耗费的时间。

ThreadPoolReader 内部未从 页缓存 读取、而是转交给线程池处理的次数。

在 ThreadPoolReader 中，未从页缓存读取而是移交给线程池处理时读取的字节数。

在 ThreadPoolReader 的异步作业中读取数据所耗费的时间——当读取不是来自页缓存时。

准备所耗费的时间 (例如调用 reader 的寻道 seek() method)

异步读取过程中从线程池任务中读取的字节数

异步读取期间从线程池任务中读取的字节数

检查内容是否已缓存所花费的时间

未在线程池中调度任务而改为同步读取的次数

同步读取的字节数

同步读取所花费的时间

异步读取期间获取数据所花费的时间

查询为满足所有限流设置而休眠的总时间。

复用另一客户端现有身份验证提供商的 S3 客户端副本数。

向 usearch 索引添加向量时计算距离的次数。

添加到 usearch 索引中的向量数。

向 usearch 索引添加向量时访问的节点数。

搜索 USearch 索引时计算距离的次数。

在 usearch 索引中执行的搜索操作次数。

搜索 usearch 索引时访问的节点数。

在未压缩缓存中命中数据块的次数 (从而避免了解压) 。

数据块在未压缩缓存中未命中的次数 (因此需要进行解压缩) 。

从未压缩缓存中淘汰的字节数。

DeleteBitmapCache 未命中时，读取并反序列化 UNIQUE KEY delete-bitmap 辅助文件所耗费的时间。

已写入的 UNIQUE KEY delete-bitmap 辅助文件数量 (每次替换 / DELETE 提交各写入一个) 。

在 UNIQUE KEY 索引缓存中命中条目的次数，因此无需加载 SST 块。

UniqueKeyIndexCache::Lookup + UniqueKeyIndexCache::Insert 中的挂钟时间 (ClickHouse 侧用于 RocksDB 块缓存的 CacheBase 适配器) 。

在 UNIQUE KEY 索引缓存中未命中条目、因此需要从磁盘加载 SST 块的次数。

SSTIndexWriter 整个生命周期内耗费的总挂钟时间——包括 SST Open、每次 addEncoded Put，以及 finalizeToStorage 中的 Finish 和通过 writeFile 执行的复制。不包括在构造 writer 之前由静态辅助函数完成的工作 (编码 + 非前缀路径排序) 。每个 writer 仅上报一次。

通过 max_network_bandwidth_for_user 限流器传输的字节数。

查询因遵循 max_network_bandwidth_for_user 限流而休眠的总时长。

处理 (查询及其他任务) 过程中，线程在用户态执行 CPU 指令所花费的总时间。这也包括因访问主内存、缓存未命中、分支预测错误、超线程等导致 CPU 管道停顿的时间。

索引粒度在向量索引缓存中被命中的次数。

索引粒度在向量索引缓存中未命中、因而必须从磁盘读取的次数。

从向量索引缓存中淘汰的字节数估计值。

对已排序列进行版本折叠所花费的总时间

加载标记所花费的时间

等待预取读取器的耗时

执行 WebAssembly 代码耗费的时间

执行 WebAssembly 代码耗费的时间

为 WebAssembly 隔离区分配的内存总量

创建的 WebAssembly 隔离区数

执行 WebAssembly 代码耗费的时间

执行 WebAssembly 代码耗费的时间

向文件描述符执行写入 (write/pwrite) 的次数。不包括套接字。

写入文件描述符的字节数。如果文件已压缩，这里显示的是压缩后数据的大小。

对文件描述符执行写入 (write/pwrite) 操作失败的次数。

WriteBufferFromHTTP 接收和发送的载荷总字节数。不包括 HTTP 请求头。

WriteBufferFromHTTP 发送的 HTTP 请求数

写入 S3 的字节数。

向 S3 写入所花费的时间。

写入 S3 时发生的异常数。

当当前请求数达到 s3_max_inflight_parts_for_one_file 定义的上限时，等待其中部分请求完成所花费的时间。

与 ZooKeeper 通信时通过网络接收的字节总数。

与 ZooKeeper 通信期间通过网络发送的字节数。

发送到 ZooKeeper 的“check”请求数。通常它们只有作为复杂事务的一部分时才有意义，单独看时意义不大。

主动关闭与 ZooKeeper 的连接的次数。

发送到 ZooKeeper 的 create 请求数。

发往 ZooKeeper 的 exists 请求数。

发送到 ZooKeeper 的“get”请求数。

ZooKeeper 的 'getACL' 请求数。

与网络相关 (连接丢失或类似情况) 的 ZooKeeper 操作中发生的异常数量。

与 ZooKeeper 成功建立连接的次数。

向 ZooKeeper 发出的“list” (getChildren) 请求数。

向 ZooKeeper 发送的 listRecursive 请求数。

发送到 ZooKeeper 的 'multi' 请求数 (复合事务) 。

ZooKeeper 读取型“multi”请求 (复合事务) 的数量。

向 ZooKeeper 发起的写入 multi 请求数 (复合事务) 。

与 ZooKeeper 交互时发生的异常数量，不包括 ZooKeeperUserExceptions 和 ZooKeeperHardwareExceptions。

发送到 ZooKeeper 的“reconfig”请求数量。

向 ZooKeeper 发出的“remove”请求数。

发往 ZooKeeper 的“set”请求数。

向 ZooKeeper 发出的 sync 请求数。这类请求通常既不常用，也很少有必要。

ZooKeeper 操作次数，包括读操作、写操作以及多重事务。

与数据相关的 ZooKeeper 操作过程中发生的异常数量 (如节点不存在、版本错误等) 。

创建请求后等待 ZooKeeper 响应所耗费的总微秒数，对所有发出请求的线程求和。

在 ZooKeeper watch 回调中 (网络线程) 花费的总耗时。

ZooKeeper watch 回调中抛出的异常数量。

从 ZooKeeper 收到 watch 通知的次数。

分派到备份/恢复协调的 watch 通知数量。

分派到 ClusterDiscovery 的 watch 通知数量。

分发到 DDLWorker 队列的 watch 通知数量。

派发给 MaterializedView 刷新协调模块的 watch 通知数量。

分派到 ObjectStorageQueue / S3Queue 的 watch 通知数量。

分派给未分类回调的 watch 通知数量。

分派给 ReplicatedAccessStorage 的 watch 通知数量。

分发给 ReplicatedMergeTree leader 选举 / 副本锁的 watch 通知数量。

分发给 ReplicatedMergeTree 日志条目的 watch 通知数量。

派发到 ReplicatedMergeTree 变更操作的 watch 通知数量。

等待副本处理日志记录 (SYNC REPLICA、ALTER、变更) 期间分发的 watch 通知数量。

分发到 UserDefinedSQLObjectsZooKeeperStorage 的 watch 通知数。

已分发到 WorkloadEntityKeeperStorage 的 watch 通知数量。