system.events

包含系统中已发生事件数量信息的系统表。

在 ClickHouse Cloud 中查询

此系统表中的数据分别保存在 ClickHouse Cloud 各节点的本地。因此，如需查看所有数据的完整情况，需要使用 clusterAllReplicas 函数。更多详情请参见此处。

​

描述

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

​

事件描述

​

ACMEAPIRequests

发起的 ACME API 请求数。

​

ACMECertificateOrders

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

​

AdaptiveAggregationBucketsRetired

在自身的合并与转换完成后、整个合并尚未结束时，其工作内存 (arena slot、暂存块引用) 即被回收的两级桶数量。

​

AdaptiveAggregationDrainedRecords

自适应聚合在合并时排空到共享表的延迟记录数。

​

AdaptiveAggregationGiveUps

在自适应聚合中，因自身数据流包含的不同键较少而放弃冻结的线程数。

​

AdaptiveAggregationLocalFreezes

自适应聚合在达到冻结阈值时冻结的本地哈希表数量。

​

AdaptiveAggregationPressureDrainedRecords

自适应聚合在内存压力下提前排空的暂存记录数。

​

AdaptiveAggregationPressureStandDowns

自适应聚合中有多少线程因内存压力超过外部聚合阈值而彻底退出学习阶段，从而使其本地表通过普通的外部聚合方式落盘。

​

AdaptiveAggregationPressureSweeps

自适应聚合因内存压力而提前排空暂存记录的次数。

​

AdaptiveAggregationProbeBypasses

在自适应聚合中，因几乎没有行命中而停止探测其已冻结本地表的线程数。

​

AdaptiveAggregationResidueReleases

自适应聚合将其共享的排空表写出的次数：当某个已退回基线算法的线程因该表即将落盘时触发。

​

AdaptiveAggregationSealedChunks

自适应聚合从缓冲的暂存批次中封存的合并块数量。

​

AdaptiveAggregationSealNormalizations

自适应聚合的 seal 阶段将多少个暂存的参数列从包装表示形式 (Const、Replicated、Sparse、LowCardinality) 归一化为排空阶段所消费的密集形式。

​

AdaptiveAggregationSharedTableSpills

自适应聚合因在内存压力下达到分片上限，而将其共享排空表落盘的次数。

​

AdaptiveAggregationSpillBacklogSheds

自适应聚合丢弃暂存积压的次数：当某个运行在基线算法上的线程 (可能是被解冻后重新放回该算法的线程，也可能是自行退出的线程) 即将落盘，而暂存记录仍驻留在内存中时，即会发生此情况。

​

AdaptiveAggregationStagedBytes

自适应聚合为合并时排空(drain)暂存的 key 字节数。

​

AdaptiveAggregationStagedChunkPiecesOverBound

自适应聚合发布的、由暂存块切分而来的分片中，仍然超出该块切分时所要满足的边界的分片数量。块按桶边界切分；若某个桶自身就超出边界，则在桶内逐条记录切分，因此这类分片就是单条记录，其暂存字节本身已超出边界；此类分片只能整体认领，其排空量可能因此超出压力分片相应的幅度。

​

AdaptiveAggregationStagedChunkSplits

自适应聚合在 publication 时沿桶边界切分暂存块的次数：因为某个块的排空量估计超过了压力分片上限。

​

AdaptiveAggregationStagedClaimsClosedAtBound

adaptive aggregation 的排空过程对暂存块发起的 claim 中，有多少次在遇到某个块之前就已关闭——该块一旦加入，批次就会触及压力分片的界限，因此该块被留给下一次 claim。该界限是针对排空后的批次而言的，因此两个各自刚好不到界限的块 (即一个被切分块的两部分，每部分仅比半个分片多出单条记录) 会被排空到两个表中，而不是一个表；只有单独就已超出界限的首个块才会被无条件 claim。

​

AdaptiveAggregationStagedRecords

自适应聚合在去重前暂存的延迟记录数。

​

AdaptiveAggregationStagedRecordsMerged

自适应聚合在 publish 和 seal 阶段因键重复而合并掉的暂存记录数。

​

AdaptiveAggregationThaws

由于暂存 stream 被判定为以重复数据为主，自适应聚合解冻本地表的次数。

​

AddressesDiscovered

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

​

地址已过期

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

​

AddressesMarkedAsFailed

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

​

AggregatingSortedMilliseconds

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

​

AggregationBucketTopKConversions

通过桶内 Top-K 选择 (即 aggregationBucketTopK 查询计划优化) 转换的两级桶数量。

​

AggregationConvertedToTwoLevel

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

​

AggregationHashTablesInitializedAsTwoLevel

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

​

AggregationOptimizedEqualRangesOfKeys

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

​

AggregationPreallocatedElementsInHashTables

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

​

AggregationTopKHeapsFrozen

有多少个 top-K 聚合堆被冻结并回退到常规聚合。原因可能是该堆在其观察窗口内几乎没有拒绝任何数据 (例如不同分组键的数量未超过 LIMIT) ，也可能是堆边界处那些永远无法被淘汰的等值集合过度膨胀 (参见 enable_group_by_top_k_optimization) 。

​

AggregationTopKKeysEvicted

聚合过程中从有界 top-K 堆中被逐出的 grouping key 数量 (参见 enable_group_by_top_k_optimization) 。

​

AggregationTopKKeysPruned

有多少被淘汰的分组键同时也从中间哈希表中被删除，且其聚合状态被销毁 (参见 enable_group_by_top_k_optimization) 。当聚合方法无法删除键，或仅按键的前缀部分进行排名时，该值会低于 AggregationTopKKeysEvicted：此时堆仍会跳过行，但哈希表会保留每一个已接纳的分组。

​

AggregationTopKRowsSkipped

在聚合过程中，因分组键无法进入 top-K 结果而被跳过的行数 (参见 enable_group_by_top_k_optimization) 。

​

AIAPICalls

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

​

AIInputTokens

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

​

AIORead

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

​

AIOReadBytes

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

​

AIOutputTokens

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

​

AIOWrite

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

​

AIOWriteBytes

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

​

AIRowsProcessed

获得 AI 结果的行数。

​

AIRowsSkipped

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

​

AllUsersThrottlerBytes

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

​

AllUsersThrottlerSleepMicroseconds

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

​

AnalyzePatchRangesMicroseconds

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

​

ApplyPatchesMicroseconds

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

​

ApplyPatchMergeOnKeyMicroseconds

在 applyPatchesMergeOnKey 排序键合并循环中耗费的总时间

​

ArenaAllocBytes

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

​

ArenaAllocChunks

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

​

ASTFuzzerOracleChecks

服务器端 AST fuzzer 尝试执行的 oracle 检查次数。

​

ASTFuzzerOracleMismatches

服务器端 AST fuzzer 检测到的 oracle 不匹配次数。

​

ASTFuzzerOracleTLPAggregateChecks

服务器端 AST fuzzer 尝试执行的 TLP Aggregate (State/Merge) oracle 检查次数。

​

ASTFuzzerQueries

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

​

ASTFuzzerSkippedBackupRestore

服务器端 AST fuzzer 跳过而未执行的经 fuzz 处理的 BACKUP/RESTORE 查询数量。

​

ASTFuzzerSkippedReplicatedDDLInternal

服务器端 AST fuzzer 因 Context 上有内部 Replicated 数据库 DDL 执行正在进行中 (存在 live 的 ZooKeeperMetadataTransaction) 而跳过 fuzzing 的次数。

​

AsynchronousReaderIgnoredBytes

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

​

AsynchronousReadWaitMicroseconds

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

​

AsynchronousRemoteReadWaitMicroseconds

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

​

AsyncInsertBytes

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

​

AsyncInsertCacheHits

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

​

AsyncInsertFlush

异步 INSERT 队列的刷写次数。每次刷写都会将一批异步 INSERT 查询作为单个分片插入。可与 AsyncInsertQuery 对比，以了解平均有多少查询被合并到一个批次中。

​

AsyncInsertQuery

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

​

AsyncInsertRows

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

​

AsyncLoaderSpawnFailures

由于全局线程池无法提供线程，异步加载器未能启动工作线程的次数。此时，排队的作业将交由线程池中已有的工作线程执行：可能是正在运行的工作线程，也可能是从等待其他池作业的状态中恢复的工作线程。

​

AsyncLoaderWaitMicroseconds

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

​

AsyncLoggingConsoleDroppedMessages

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

​

AsyncLoggingConsoleTotalMessages

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

​

AsyncLoggingErrorFileLogDroppedMessages

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

​

AsyncLoggingErrorFileLogTotalMessages

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

​

AsyncLoggingFileLogDroppedMessages

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

​

AsyncLoggingFileLogTotalMessages

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

​

AsyncLoggingSyslogDroppedMessages

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

​

AsyncLoggingSyslogTotalMessages

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

​

AsyncLoggingTextLogDroppedMessages

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

​

AsyncLoggingTextLogTotalMessages

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

​

AzureCommitBlockList

Azure Blob 存储 API CommitBlockList 的调用次数

​

AzureCopyObject

Azure Blob 存储 API 的 CopyObject 调用次数

​

AzureCreateContainer

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

​

AzureDeleteObjects

Azure Blob 存储 API DeleteObject 调用次数。

​

AzureGetObject

Azure API GetObject 调用次数。

​

AzureGetProperties

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

​

AzureGetRequestThrottlerBlocked

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

​

AzureGetRequestThrottlerCount

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

​

AzureGetRequestThrottlerSleepMicroseconds

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

​

AzureListObjects

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

​

AzurePutRequestThrottlerBlocked

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

​

AzurePutRequestThrottlerCount

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

​

AzurePutRequestThrottlerSleepMicroseconds

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

​

AzureReadMicroseconds

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

​

AzureReadRequestsCount

Azure 读取请求数。

​

AzureReadRequestsErrors

Azure 读取请求错误数。

​

AzureReadRequestsRedirects

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

​

AzureReadRequestsThrottling

被限流的 Azure 读取请求数。

​

AzureStageBlock

Azure Blob 存储 API 的 StageBlock 调用次数

​

AzureUpload

Azure Blob 存储 API 的 Upload 调用次数

​

AzureWriteMicroseconds

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

​

AzureWriteRequestsCount

Azure 写入请求数。

​

AzureWriteRequestsErrors

Azure 写入请求错误数。

​

AzureWriteRequestsRedirects

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

​

AzureWriteRequestsThrottling

被限流的 Azure 写入请求数。

​

BackgroundLoadingMarksTasks

后台加载标记任务数

​

BackupEntriesCollectorForTablesDataMicroseconds

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

​

BackupEntriesCollectorMicroseconds

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

​

BackupEntriesCollectorRunPostTasksMicroseconds

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

​

BackupLockFileReads

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

​

BackupPreparingFileInfosMicroseconds

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

​

BackupReadLocalBytesToCalculateChecksums

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

​

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

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

​

BackupReadMetadataMicroseconds

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

​

BackupReadRemoteBytesToCalculateChecksums

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

​

BackupReadRemoteFilesToCalculateChecksums

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

​

BackupsOpenedForRead

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

​

BackupsOpenedForUnlock

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

​

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

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

​

BackupThrottlerBytes

通过 max_backup_bandwidth_for_server 限流器的字节数。

​

BackupThrottlerSleepMicroseconds

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

​

BackupWriteMetadataMicroseconds

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

​

BlobCopierThreadLockBlobsErrors

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

​

BlobCopierThreadLockedBlobs

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

​

BlobCopierThreadRecordBlobsErrors

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

​

BlobCopierThreadRecordedBlobs

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

​

BlobCopierThreadReplicateBlobsErrors

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

​

BlobCopierThreadReplicatedBlobs

BlobCopier 已复制的 blob 数量

​

BlobCopierThreadRuns

BlobCopier 线程执行次数

​

BlobKillerThreadLockBlobsErrors

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

​

BlobKillerThreadLockedBlobs

元数据存储返回的 blob 数量

​

BlobKillerThreadRecordBlobsErrors

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

​

BlobKillerThreadRecordedBlobs

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

​

BlobKillerThreadRemoveBlobsErrors

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

​

BlobKillerThreadRemovedBlobs

BlobKiller 删除的 blob 数量

​

BlobKillerThreadRemoveTasks

BlobKiller 创建的删除任务数

​

BlobKillerThreadRuns

BlobKiller 线程的执行次数

​

BuildPatchesJoinMicroseconds

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

​

BuildPatchesMergeMicroseconds

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

​

CachedReadBufferCacheWriteBytes

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

​

CachedReadBufferCacheWriteMicroseconds

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

​

CachedReadBufferCacheWriteStopped

向文件系统缓存写入 File 段时在下载中途被中止的次数 (空间预留失败或缓存写入失败) ，此后读取将绕过缓存继续进行

​

CachedReadBufferCreateBufferMicroseconds

准备 buffer 所用时间

​

CachedReadBufferPredownloadedBytes

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

​

CachedReadBufferPredownloadedFromSourceBytes

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

​

CachedReadBufferPredownloadedFromSourceMicroseconds

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

​

CachedReadBufferReadFromCacheBytes

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

​

CachedReadBufferReadFromCacheHits

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

​

CachedReadBufferReadFromCacheMicroseconds

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

​

CachedReadBufferReadFromCacheMisses

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

​

CachedReadBufferReadFromSourceBytes

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

​

CachedReadBufferReadFromSourceMicroseconds

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

​

CachedReadBufferWaitReadBufferMicroseconds

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

​

CachedWriteBufferCacheWriteBytes

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

​

CachedWriteBufferCacheWriteMicroseconds

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

​

CachedWriteBufferCacheWriteStopped

写透缓存被停止的次数 (空间预留失败、缓存写入失败，或覆盖该范围的片段正被逐出) ，此后写入将继续进行，但不再写入缓存

​

CachedWriteBufferCoveringSegmentShrinkFailed

写透缓存因以下原因被迫停止的次数：落后于当前写入 offset 的覆盖 File 段无法收缩 (它正被其他方持有，因此其中的空洞无法消除) ，或该段被并发驱逐

​

CachedWriteBufferCoveringSegmentShrunk

写透缓存为在新的 File 段中继续缓存，而收缩某个滞留在当前写入 offset 之后的覆盖 File 段 (中间的 ranges 交由另一台分布式缓存服务器处理) 的次数

​

CacheWarmerBytesDownloaded

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

​

CacheWarmerDataPartsDownloaded

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

​

CannotRemoveEphemeralNode

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

​

CannotWriteToWriteBufferDiscard

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

​

CoalescingSortedMilliseconds

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

​

CollapsingSortedMilliseconds

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

​

CommonBackgroundExecutorTaskCancelMicroseconds

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

​

CommonBackgroundExecutorTaskExecuteStepMicroseconds

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

​

CommonBackgroundExecutorTaskResetMicroseconds

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

​

CommonBackgroundExecutorWaitMicroseconds

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

​

CompiledFunctionExecute

已编译函数的执行次数。

​

CompileExpressionsBytes

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

​

CompileExpressionsMicroseconds

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

​

CompileFunction

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

​

CompileRegexpFunction

正则表达式被 JIT 编译为机器代码的次数。

​

CompressedReadBufferBlocks

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

​

CompressedReadBufferBytes

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

​

CompressedReadBufferChecksumDoesntMatch

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

​

CompressedReadBufferChecksumDoesntMatchMicroseconds

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

​

CompressedReadBufferChecksumDoesntMatchSingleBitMismatch

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

​

ConcurrencyControlDownscales

CPU 缩容事件总数

​

ConcurrencyControlPreemptedMicroseconds

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

​

ConcurrencyControlPreemptions

CPU 抢占总次数

​

ConcurrencyControlQueriesDelayed

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

​

ConcurrencyControlSlotsAcquired

获取的 CPU 插槽总数

​

ConcurrencyControlSlotsAcquiredNonCompeting

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

​

ConcurrencyControlSlotsDelayed

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

​

ConcurrencyControlSlotsGranted

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

​

ConcurrencyControlUpscales

CPU 扩容事件总数

​

ConcurrencyControlWaitMicroseconds

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

​

ConcurrentQuerySlotsAcquired

获取到的查询槽位总数

​

ConcurrentQueryWaitMicroseconds

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

​

ConnectionPoolIsFullMicroseconds

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

​

ContextLock

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

​

ContextLockWaitMicroseconds

Context 锁等待时长 (微秒)

​

CoordinatedMergesMergeAssignmentRequest

合并分配 请求的总数

​

CoordinatedMergesMergeAssignmentRequestMicroseconds

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

​

CoordinatedMergesMergeAssignmentResponse

合并分配请求总数

​

CoordinatedMergesMergeAssignmentResponseMicroseconds

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

​

CoordinatedMergesMergeCoordinatorFetchMetadataMicroseconds

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

​

CoordinatedMergesMergeCoordinatorFilterMicroseconds

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

​

CoordinatedMergesMergeCoordinatorLockStateExclusivelyCount

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

​

CoordinatedMergesMergeCoordinatorLockStateExclusivelyMicroseconds

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

​

CoordinatedMergesMergeCoordinatorLockStateForShareCount

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

​

CoordinatedMergesMergeCoordinatorLockStateForShareMicroseconds

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

​

CoordinatedMergesMergeCoordinatorSelectMergesMicroseconds

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

​

CoordinatedMergesMergeCoordinatorUpdateCount

合并协调器 的更新总次数

​

CoordinatedMergesMergeCoordinatorUpdateMicroseconds

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

​

CoordinatedMergesMergeWorkerUpdateCount

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

​

CoordinatedMergesMergeWorkerUpdateMicroseconds

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

​

CreatedLogEntryForMerge

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

​

CreatedLogEntryForMutation

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

​

CreatedReadBufferDirectIO

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

​

CreatedReadBufferDirectIOFailed

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

​

CreatedReadBufferMMap

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

​

CreatedReadBufferMMapFailed

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

​

CreatedReadBufferOrdinary

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

​

合并后数据与副本不同

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

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

​

DataAfterMutationDiffersFromReplica

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

​

DefaultImplementationForNullsRows

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

​

DefaultImplementationForNullsRowsWithNulls

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

​

DelayedInserts

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

​

DelayedInsertsMilliseconds

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

​

DelayedMutations

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

​

DelayedMutationsMilliseconds

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

​

DeltaLakeDeltaLogExistenceChecks

为检查 DeltaLake _delta_log 是否存在而发起的对象存储列举 (listing) 次数 (例如在 CREATE TABLE 期间) 。

​

DeltaLakePartitionPrunedFiles

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

​

DeltaLakeScannedFiles

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

​

DeltaLakeSnapshotInitializations

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

​

DictCacheKeysExpired

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

​

DictCacheKeysHit

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

​

DictCacheKeysNotFound

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

​

DictCacheKeysRequested

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

​

DictCacheKeysRequestedFound

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

​

DictCacheKeysRequestedMiss

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

​

DictCacheLockReadNs

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

​

DictCacheLockWriteNs

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

​

DictCacheRequests

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

​

DictCacheRequestTimeNs

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

​

DirectorySync

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

​

DirectorySyncElapsedMicroseconds

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

​

DiskAzureCommitBlockList

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

​

DiskAzureCopyObject

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

​

DiskAzureCreateContainer

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

​

DiskAzureDeleteObjects

Azure Blob 存储 API DeleteObject 调用次数。

​

DiskAzureGetObject

Disk Azure API GetObject 的调用次数。

​

DiskAzureGetProperties

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

​

DiskAzureGetRequestThrottlerBlocked

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

​

DiskAzureGetRequestThrottlerCount

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

​

DiskAzureGetRequestThrottlerSleepMicroseconds

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

​

DiskAzureListObjects

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

​

DiskAzurePutRequestThrottlerBlocked

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

​

DiskAzurePutRequestThrottlerCount

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

​

DiskAzurePutRequestThrottlerSleepMicroseconds

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

​

DiskAzureReadMicroseconds

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

​

DiskAzureReadRequestsCount

Azure 磁盘读取请求数。

​

DiskAzureReadRequestsErrors

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

​

DiskAzureReadRequestsRedirects

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

​

DiskAzureReadRequestsThrottling

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

​

DiskAzureStageBlock

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

​

DiskAzureUpload

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

​

DiskAzureWriteMicroseconds

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

​

DiskAzureWriteRequestsCount

Azure 磁盘写请求数。

​

DiskAzureWriteRequestsErrors

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

​

DiskAzureWriteRequestsRedirects

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

​

DiskAzureWriteRequestsThrottling

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

​

DiskConnectionsCreated

磁盘已创建的连接数

​

DiskConnectionsElapsedMicroseconds

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

​

DiskConnectionsErrors

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

​

DiskConnectionsExpired

磁盘的过期连接数

​

DiskConnectionsPreserved

磁盘保留连接数

​

DiskConnectionsReset

磁盘被重置的连接数

​

DiskConnectionsReused

磁盘复用连接数

​

DiskObjectStorageWaitBlobRemovalMicroseconds

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

​

DiskPlainRewritableAzureDirectoryCreated

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

​

DiskPlainRewritableAzureDirectoryRemoved

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

​

DiskPlainRewritableLegacyLayoutDiskCount

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

​

DiskPlainRewritableLocalDirectoryCreated

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

​

DiskPlainRewritableLocalDirectoryRemoved

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

​

DiskPlainRewritableS3DirectoryCreated

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

​

DiskPlainRewritableS3DirectoryRemoved

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

​

DiskPlainRewritableUndoStageRetries

因对象存储拒绝请求，回滚失败的 ‘plain_rewritable’ 元数据事务时某个 step 必须重试的次数。

​

DiskReadElapsedMicroseconds

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

​

DiskS3AbortMultipartUpload

DiskS3 API 的 AbortMultipartUpload 调用次数。

​

DiskS3CompleteMultipartUpload

DiskS3 API 的 CompleteMultipartUpload 调用次数。

​

DiskS3CopyObject

DiskS3 API 的 CopyObject 调用次数。

​

DiskS3CreateMultipartUpload

DiskS3 API 的 CreateMultipartUpload 调用次数。

​

DiskS3DeleteObjects

DiskS3 API DeleteObject 调用次数。

​

DiskS3GetObject

DiskS3 API 的 GetObject 调用次数。

​

DiskS3GetObjectTagging

DiskS3 API GetObjectTagging 的调用次数。

​

DiskS3GetRequestThrottlerBlocked

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

​

DiskS3GetRequestThrottlerCount

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

​

DiskS3GetRequestThrottlerSleepMicroseconds

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

​

DiskS3HeadObject

DiskS3 API 的 HeadObject 调用次数。

​

DiskS3ListObjects

DiskS3 API 的 ListObjects 调用次数。

​

DiskS3PutObject

DiskS3 API 的 PutObject 调用次数。

​

DiskS3PutRequestThrottlerBlocked

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

​

DiskS3PutRequestThrottlerCount

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

​

DiskS3PutRequestThrottlerSleepMicroseconds

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

​

DiskS3ReadMicroseconds

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

​

DiskS3ReadRequestAttempts

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

​

DiskS3ReadRequestRetryableErrors

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

​

DiskS3ReadRequestsCount

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

​

DiskS3ReadRequestsErrors

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

​

DiskS3ReadRequestsRedirects

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

​

DiskS3ReadRequestsThrottling

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

​

DiskS3UploadPart

DiskS3 API 的 UploadPart 调用次数。

​

DiskS3UploadPartCopy

DiskS3 API UploadPartCopy 调用的次数。

​

DiskS3WriteMicroseconds

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

​

DiskS3WriteRequestAttempts

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

​

DiskS3WriteRequestRetryableErrors

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

​

DiskS3WriteRequestsCount

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

​

DiskS3WriteRequestsErrors

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

​

DiskS3WriteRequestsRedirects

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

​

DiskS3WriteRequestsThrottling

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

​

DiskWriteElapsedMicroseconds

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

​

DistinctTransformsAbandonedDeduplication

有多少个去重转换因观察到的输入几乎全部为唯一值、且下游消费者本身也会去重，而丢弃了自己的哈希表并停止去重：包括预备 DISTINCT (参见 allow_preliminary_distinct_abandoning) 以及 IN 子查询 set 填充之前按 stream 进行的预去重。

​

DistinctTransformsSwitchedToPassThrough

有多少个预处理 DISTINCT 转换因查询内存超出外部 DISTINCT 阈值，或预计的哈希分配会超出剩余的阈值预算 (参见 max_bytes_before_external_distinct) ，而释放了自身的哈希表并开始将每一行直接透传：此时改由会落盘的最终 DISTINCT 来去除重复数据。

​

DistrCacheBackgroundWrites

分布式缓存写入缓冲区事件。在后台线程上执行的缓存写入次数 (即已获取后台写入槽位)

​

DistrCacheConnectAttempts

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

​

DistrCacheConnectErrors

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

​

DistrCacheConnectMicroseconds

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

​

DistrCacheEstimatedInflightBytesOnSeek

分布式缓存读取缓冲区事件。在考虑丢弃 connection 的那些寻道操作时，估算的在传输中的字节数 (可与 DistrCacheUnusedDataPacketsBytesReadRangeIdChanged 对比)

​

DistrCacheFallbackReadMicroseconds

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

​

DistrCacheGetClientMicroseconds

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

​

DistrCacheGetResponseMicroseconds

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

​

DistrCacheHashRingRebuilds

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

​

DistrCacheInlineWrites

分布式缓存写入缓冲区事件。在调用线程上以内联方式执行的缓存写入次数 (即临时数据的写入，这类写入没有可与之重叠的对象存储写入)

​

DistrCacheLockRegistryMicroseconds

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

​

DistrCacheMakeRequestErrors

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

​

DistrCacheNextImplMicroseconds

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

​

DistrCacheObjectStorageWriteBytes

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

​

DistrCacheObjectStorageWriteMicroseconds

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

​

DistrCacheOpenedConnections

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

​

DistrCacheOpenedConnectionsBypassingPool

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

​

DistrCachePrecomputeRangesMicroseconds

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

​

DistrCacheRangeChange

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

​

DistrCacheRangeResetBackward

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

​

DistrCacheRangeResetForward

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

​

DistrCacheReadBytesFromFallbackBuffer

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

​

DistrCacheReadBytesSkippedOnSeek

分布式缓存读取缓冲区事件。在向前寻道以复用已打开的 stream 时，被丢弃的在传输中的字节数

​

DistrCacheReadBytesUnconsumedOnEndRequest

分布式缓存读取缓冲区事件。请求提前结束时，所请求读取范围中尚未被消费的字节数

​

DistrCacheReadErrors

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

​

DistrCacheReadErrorsNonRetriable

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

​

DistrCacheReadErrorsRetriable

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

​

DistrCacheReadMicroseconds

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

​

DistrCacheReadRequestRetries

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

​

DistrCacheReadRequestRetriesExhausted

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

​

DistrCacheReadThrottlerBytes

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

​

DistrCacheReadThrottlerSleepMicroseconds

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

​

DistrCacheReceivedCredentialsRefreshPackets

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

​

DistrCacheReceivedDataPackets

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

​

DistrCacheReceivedDataPacketsBytes

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

​

DistrCacheReceivedErrorPackets

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

​

DistrCacheReceivedOkPackets

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

​

DistrCacheReceivedSlowDownPackets

Distributed Cache 客户端事件。从分布式缓存接收到的 SlowDown packet 总数 (服务器拒绝新连接，因为该客户端相对于其权重打开了过多连接)

​

DistrCacheReceivedStopPackets

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

​

DistrCacheReceiveResponseErrors

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

​

DistrCacheRegistryUpdateMicroseconds

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

​

DistrCacheRegistryUpdates

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

​

DistrCacheRemoveOutdatedMicroseconds

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

​

DistrCacheReusedConnections

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

​

DistrCacheSeekBufferedBytesShortfall

分布式缓存读取缓冲区事件。当跳过请求被拒绝时，本地缓冲数据相比间隙所缺少的字节数

​

DistrCacheSeekCancelledRequests

分布式缓存读取缓冲区事件。寻道操作取消打开请求而非复用 stream 的次数

​

DistrCacheSeekReRequestFirstPacketMicroseconds

分布式缓存读取缓冲区事件。从因寻道而在已打开的 stream 上请求新的读取范围，到收到其第一个数据包之间的时间

​

DistrCacheSeekReRequests

分布式缓存读取缓冲区事件。寻道操作在同一 connection 上请求新的 读取范围 的次数

​

DistrCacheSeekSkipDeclinedGapNotBuffered

分布式缓存读取缓冲区事件。由于间隙未在本地缓冲而无法跳过的向前寻道次数

​

DistrCacheSeekSkips

分布式缓存读取缓冲区事件。在已打开的 stream 上跳过空隙的向前寻道次数

​

DistrCacheSentDataPackets

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

​

DistrCacheSentDataPacketsBytes

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

​

DistrCacheServerAckRequestPackets

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

​

DistrCacheServerCachedReadBufferCacheHits

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

​

DistrCacheServerCachedReadBufferCacheMisses

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

​

DistrCacheServerCachedReadBufferCachePredownloadBytes

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

​

DistrCacheServerCachedReadBufferCacheReadBytes

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

​

DistrCacheServerCachedReadBufferCacheWrittenBytes

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

​

DistrCacheServerCachedReadBufferObjectStorageReadBytes

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

​

DistrCacheServerConnectionRegistryClientLockWaitMicroseconds

分布式缓存服务器事件。出现竞争 (注册/注销/识别/淘汰) 时，等待单个客户端连接桶互斥锁 所花费的时间

​

DistrCacheServerConnectionRegistryLockWaitMicroseconds

分布式缓存服务器事件。出现争用时等待全局 connection registry 互斥锁 所耗费的时间 (包括 identify、setClientWeight、eviction，以及需要重新索引或移除桶时的 unregister)

​

DistrCacheServerConnectionsDroppedOverLimit

分布式缓存服务器事件。因连接数超过限制而被关闭的连接数 (从按权重折算后连接数最多的客户端上关闭)

​

DistrCacheServerConnectionsRejectedOverLimit

分布式缓存服务器事件。因发起连接的客户端超出其连接配额，而以 SlowDown packet 拒绝的新连接数

​

DistrCacheServerContinueRequestPackets

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

​

DistrCacheServerCredentialsRefresh

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

​

DistrCacheServerEndRequestPackets

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

​

DistrCacheServerNewS3CachedClients

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

​

DistrCacheServerProcessRequestMicroseconds

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

​

DistrCacheServerReceivedCredentialsRefreshPackets

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

​

DistrCacheServerReusedS3CachedClients

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

​

DistrCacheServerShutdownConnectionsMicroseconds

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

​

DistrCacheServerSkipped

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

​

DistrCacheServerStartRequestPackets

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

​

DistrCacheServerSwitches

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

​

DistrCacheServerUpdates

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

​

DistrCacheSkippedWrites

分布式缓存写入缓冲区事件。由于没有空闲的后台写入槽位 (已达到服务器设置 distributed_cache_write_pool_size 设定的上限) ，或后台写入无法启动，而跳过写穿缓存写入的写入缓冲区数量。数据仍会写入对象存储

​

DistrCacheStaleReconnections

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

​

DistrCacheStartRangeMicroseconds

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

​

DistrCacheSuccessfulConnectAttempts

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

​

DistrCacheSuccessfulRegistryUpdates

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

​

DistrCacheSystemTablesErrors

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

​

DistrCacheTemporaryFilesBytesWritten

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

​

DistrCacheTemporaryFilesCreated

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

​

DistrCacheUnsuccessfulConnectAttempts

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

​

DistrCacheUnsuccessfulRegistryUpdates

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

​

DistrCacheUnusedDataPacketsBytes

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

​

DistrCacheUnusedDataPacketsBytesReadRangeIdChanged

Distributed Cache 客户端事件。被忽略的 Data 数据包 中的字节数 (属于 DistrCacheUnusedDataPacketsBytes 的一部分) ，这些数据包属于被跟踪的请求，但对应的是较旧的 read range id (同一请求上已请求了更新的 read range)

​

DistrCacheUnusedDataPacketsBytesUnknownRequest

Distributed Cache 客户端事件。被忽略的 Data 数据包中的字节数 (属于 DistrCacheUnusedDataPacketsBytes 的一部分) ，这些数据包所对应的请求已不再被客户端跟踪 (例如服务器已发送更多数据后，读取通过 EndRequest 被停止)

​

DistrCacheUnusedPackets

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

​

DistrCacheUnusedPacketsBufferAllocations

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

​

DistrCacheWriteBytes

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

​

DistrCacheWriteErrors

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

​

DistrCacheWriteErrorsNonRetriable

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

​

DistrCacheWriteErrorsRetriable

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

​

DistrCacheWriteMicroseconds

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

​

DistrCacheWriteRequestRetries

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

​

DistrCacheWriteRequestRetriesExhausted

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

​

DistrCacheWriteThrottlerBytes

通过 max_distributed_cache_write_bandwidth_for_server 限流器的字节数。

​

DistrCacheWriteThrottlerSleepMicroseconds

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

​

DistributedAsyncInsertionFailures

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

​

DistributedConnectionConnectCount

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

​

DistributedConnectionFailAtAll

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

​

DistributedConnectionFailTry

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

​

DistributedConnectionMissingTable

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

​

DistributedConnectionReconnectCount

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

​

DistributedConnectionSkipReadOnlyReplica

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

​

DistributedConnectionStaleReplica

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

​

DistributedConnectionTries

分布式连接尝试总次数。

​

DistributedConnectionUsable

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

​

DistributedDelayedInserts

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

​

DistributedDelayedInsertsMilliseconds

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

​

DistributedIndexAnalysisMicroseconds

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

​

DistributedIndexAnalysisMissingParts

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

​

DistributedIndexAnalysisParts

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

​

DistributedIndexAnalysisReplicaFallback

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

​

DistributedIndexAnalysisReplicaUnavailable

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

​

DistributedIndexAnalysisScheduledReplicas

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

​

DistributedPlanHostsUsed

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

​

DistributedPlanLocalExecution

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

​

DistributedPlanRemoteTasks

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

​

DistributedPlanWorkerPartsPruned

工作线程通过自身的索引分析，从分配给它的数据分区片段中裁剪掉的数量，这些数据分区片段因此无需被该工作线程读取。coordinator 在选择 parts 时并不进行该分析，因此可能会分配到查询中没有任何行能够匹配的分片。DistributedPlanWorkerPartsReceived 等于该指标与 DistributedPlanWorkerPartsScanned 之和。

​

DistributedPlanWorkerPartsReceived

coordinator 分配给 distributed query plan 中某个工作线程的数据分区片段数量，按查询在该工作线程上执行的分桶读取累加。若某个分片被分配到多个桶，则每次读取各计一次。

​

DistributedPlanWorkerPartsScanned

工作线程保留下来用于读取的已分配数据分区片段数量。

​

DistributedRejectedInserts

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

​

DistributedShardsSkipped

启用 skip_unavailable_shards 时，向 分布式表 (或 remote/cluster 表函数) 发起查询过程中被静默跳过的分片数量；跳过的原因可能是该分片不可用，或该分片引发了 skip_unavailable_shards_mode 所涵盖的异常。

​

DistributedSyncInsertionTimeoutExceeded

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

​

DNSError

DNS 解析错误总数

​

DuplicatedAsyncInserts

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

​

DuplicatedInsertedBlocks

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

​

DuplicationDataHashComputations

对 INSERT 到 *MergeTree 表的块进行去重时，执行的按列数据哈希计算次数 (统一去重哈希中的缓存未命中) 。

​

DuplicationElapsedMicroseconds

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

​

EncryptionHeaderCacheHits

在 encryption header cache 中命中 encryption header 字节的次数，此时会跳过对该 header 的源端读取。

​

EncryptionHeaderCacheMisses

在 encryption header cache 中未找到 encryption header 字节，因而不得不从源读取的次数。

​

EngineFileLikeReadFiles

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

​

ExecutableUserDefinedFunctionElapsedMicroseconds

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

​

ExecutableUserDefinedFunctionInputBytes

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

​

ExecutableUserDefinedFunctionInvocations

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

​

ExecutableUserDefinedFunctionOutputBytes

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

​

ExecutableUserDefinedFunctionPeakMemoryByteSeconds

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

​

ExecutableUserDefinedFunctionPoolWaitMicroseconds

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

​

ExecutableUserDefinedFunctionSystemTimeMicroseconds

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

​

ExecutableUserDefinedFunctionUserTimeMicroseconds

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

​

ExecuteShellCommand

执行 shell 命令的次数。

​

ExternalAggregationCompressedBytes

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

​

ExternalAggregationMerge

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

​

ExternalAggregationUncompressedBytes

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

​

ExternalAggregationWritePart

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

​

ExternalDataSourceLocalCacheReadBytes

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

​

ExternalDistinctCompressedBytes

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

​

ExternalDistinctMerge

在外部内存中为 DISTINCT 合并临时 File 的次数。

​

ExternalDistinctUncompressedBytes

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

​

ExternalDistinctWritePart

在外部内存中执行 DISTINCT 时，将临时 File写入磁盘的次数。

​

ExternalJoinCompressedBytes

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

​

ExternalJoinMerge

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

​

ExternalJoinUncompressedBytes

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

​

ExternalJoinWritePart

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

​

ExternalProcessingCompressedBytesTotal

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

​

ExternalProcessingFilesTotal

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

​

ExternalProcessingUncompressedBytesTotal

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

​

ExternalSortCompressedBytes

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

​

ExternalSortMerge

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

​

ExternalSortUncompressedBytes

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

​

ExternalSortWritePart

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

​

FailedAsyncInsertQuery

失败的 ASYNC INSERT 查询数。

​

FailedInitialQuery

初始查询失败次数。

​

FailedInitialSelectQuery

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

​

FailedInsertQuery

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

​

FailedInternalInsertQuery

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

​

FailedInternalQuery

失败的内部查询数。

​

FailedInternalSelectQuery

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

​

FailedQuery

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

​

FailedSelectQuery

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

​

FetchBackgroundExecutorTaskCancelMicroseconds

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

​

FetchBackgroundExecutorTaskExecuteStepMicroseconds

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

​

FetchBackgroundExecutorTaskResetMicroseconds

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

​

FetchBackgroundExecutorWaitMicroseconds

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

​

FiberStackAllocBytes

为纤程栈分配的字节数，包括保护页 (保护页仅在 debug 和 sanitizer 构建中使用) 。

​

FiberStackAllocNanoseconds

分配纤程栈所耗费的时间。之所以使用纳秒为单位，是因为单次分配通常耗时不到一微秒，除非 allocator 或 kernel 出现争用。

​

FiberStackAllocs

为 纤程 分配的栈数量 (纤程 用于与远程副本进行异步通信) 。

​

FiberStackFreeNanoseconds

释放纤程栈所花费的时间。

​

FileOpen

已打开的文件数量。

​

FileProgressCallback 调用次数

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

​

FileSegmentCompleteMicroseconds

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

​

FileSegmentFailToIncreasePriority

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

​

FileSegmentHolderCompleteMicroseconds

File 段持有器 complete() 耗时

​

FileSegmentIncreasePriorityMicroseconds

File 段优先级提升时间

​

FileSegmentLockMicroseconds

锁定 File 段耗时

​

FileSegmentRemoveMicroseconds

File 段 remove() 耗时

​

FileSegmentWaitMicroseconds

在 DOWNLOADING 状态下等待

​

FileSegmentWaitTimeouts

等待处于 DOWNLOADING 状态的 File 段时发生超时的次数 (参见 filesystem_cache_wait_for_concurrent_download_timeout_milliseconds)

​

FileSegmentWriteMicroseconds

File 段 write() 耗时

​

FileSync

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

​

FileSyncElapsedMicroseconds

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

​

FilesystemCacheBackgroundDownloadQueuePush

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

​

FilesystemCacheBackgroundEvictedBytes

后台线程淘汰的字节数

​

FilesystemCacheBackgroundEvictedFileSegments

后台线程淘汰的 File 段数量

​

FilesystemCacheBackgroundRemovedInvalidatedEntries

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

​

FilesystemCacheCheckCorrectness

FileCache::assertCacheCorrectness 被调用的次数

​

FilesystemCacheCheckCorrectnessMicroseconds

FileCache::assertCacheCorrectness 耗费的时间

​

FilesystemCacheClientsMapLockWaitMicroseconds

在 overcommit 缓存策略中，等待存在争用的按客户端 (user_id) 用量 map 分片锁所耗费的时间

​

FilesystemCacheCreatedKeyDirectories

已创建的键目录数

​

FilesystemCacheDowngradedFileSegments

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

​

FilesystemCacheEvictedBytes

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

​

FilesystemCacheEvictedFileSegments

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

​

FilesystemCacheEvictionReusedIterator

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

​

FilesystemCacheEvictionSkippedEvictingFileSegments

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

​

FilesystemCacheEvictionSkippedFileSegments

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

​

FilesystemCacheEvictionSkippedMovingFileSegments

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

​

FilesystemCacheEvictionTries

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

​

FilesystemCacheEvictMicroseconds

文件系统缓存淘汰时间

​

FilesystemCacheFailedEvictionCandidates

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

​

FilesystemCacheFailedReserveAttempts

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

​

FilesystemCacheFailToReserveSpaceBecauseOfCacheResize

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

​

FilesystemCacheFailToReserveSpaceBecauseOfLockContention

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

​

FilesystemCacheFreeSpaceKeepingThreadErrors

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

​

FilesystemCacheFreeSpaceKeepingThreadRun

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

​

FilesystemCacheFreeSpaceKeepingThreadWorkMilliseconds

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

​

FilesystemCacheGetMicroseconds

文件系统缓存 get() 耗时

​

FilesystemCacheGetOrSetMicroseconds

文件系统缓存 getOrSet() 耗时

​

FilesystemCacheHoldFileSegments

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

​

FilesystemCacheIdleClientEvictions

因在 idle_client_ttl_sec 时间内未发生任何访问，而清除空闲分布式缓存客户端 (user_id) 全部缓存条目的次数。

​

FilesystemCacheInvalidatedEntriesCleanupThreadWorkMilliseconds

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

​

FilesystemCacheLoadMetadataMicroseconds

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

​

FilesystemCacheLockKeyMicroseconds

锁定缓存键所用时间

​

FilesystemCacheLockMetadataMicroseconds

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

​

FilesystemCacheLockOriginPoolMicroseconds

对文件系统缓存共享 origin pool 加锁的耗时

​

FilesystemCacheOvercommitCandidatesIterationSteps

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

​

FilesystemCachePriorityReadLockMicroseconds

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

​

FilesystemCachePriorityWriteLockMicroseconds

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

​

FilesystemCacheReserveAttempts

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

​

FilesystemCacheReserveMicroseconds

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

​

FilesystemCacheStateLockMicroseconds

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

​

FilesystemCacheUnusedHoldFileSegments

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

​

FilteringMarksWithPrimaryKeyMicroseconds

按 PK 过滤 parts 耗费的时间。

​

主键分析期间处理的过滤标记数

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

​

FilteringMarksWithSecondaryKeysMicroseconds

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

​

FilterPartsByVirtualColumnsMicroseconds

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

​

FilterTransformPassedBytes

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

​

FilterTransformPassedRows

查询中过滤后保留的行数

​

FunctionExecute

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

​

GatheredColumns

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

​

GatheringColumnMilliseconds

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

​

GlobalMemoryLimitExceeded

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

​

GlobalThreadPoolExpansions

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

​

GlobalThreadPoolJobs

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

​

GlobalThreadPoolJobWaitTimeMicroseconds

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

​

GlobalThreadPoolLockWaitMicroseconds

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

​

GlobalThreadPoolShrinks

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

​

GlobalThreadPoolThreadCreationMicroseconds

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

​

硬缺页错误

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

​

HashJoinPreallocatedElementsInHashTables

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

​

HedgedRequestsChangeReplica

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

​

HTTPConnectionsCreated

已创建的客户端 HTTP 连接数

​

HTTPConnectionsElapsedMicroseconds

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

​

HTTPConnectionsErrors

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

​

HTTPConnectionsExpired

已过期的客户端 HTTP 连接数

​

HTTPConnectionsPreserved

保留的客户端 HTTP 连接数量

​

HTTPConnectionsReset

已重置的客户端 HTTP 连接数

​

HTTPConnectionsReused

复用的客户端 HTTP 连接数

​

HTTPServerConnectionsClosed

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

​

HTTPServerConnectionsCreated

已创建的服务器 HTTP 连接数

​

HTTPServerConnectionsExpired

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

​

HTTPServerConnectionsPreserved

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

​

HTTPServerConnectionsReset

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

​

HTTPServerConnectionsReused

复用的服务器 HTTP 连接数

​

IcebergIteratorInitializationMicroseconds

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

​

IcebergMetadataFilesCacheHits

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

​

IcebergMetadataFilesCacheMisses

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

​

IcebergMetadataFilesCacheStaleMisses

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

​

IcebergMetadataFilesCacheWeightLost

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

​

IcebergMetadataReadWaitTimeMicroseconds

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

​

IcebergMetadataReturnedObjectInfos

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

​

IcebergMetadataUpdateMicroseconds

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

​

IcebergMinMaxIndexPrunedFiles

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

​

IcebergMinMaxNonPrunedDeleteFiles

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

​

IcebergMinMaxPrunedDeleteFiles

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

​

IcebergPartitionPrunedFiles

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

​

IcebergPartitionPrunedManifestFiles

借助 manifest 列表中的分区摘要，被跳过而未读取的 Iceberg manifest 文件数量

​

IcebergTrivialCountOptimizationApplied

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

​

IcebergVersionHintUsed

version-hint.text 的使用次数。

​

IgnoredColdParts

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

​

IndexAnalysisRounds

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

​

IndexBinarySearchAlgorithm

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

​

IndexGenericExclusionSearchAlgorithm

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

​

IndexGenericExclusionSearchStepLimitReached

在索引标记上执行 generic exclusion search 时达到 merge_tree_generic_exclusion_search_max_steps 上限，从而直接接受剩余 mark ranges、不再继续拆分的次数

​

InitialQuery

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

​

InitialSelectQuery

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

​

InsertedBytes

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

​

InsertedCompactParts

以 Compact 格式插入的 parts 数量。

​

InsertedRows

插入到所有表中的行数。

​

InsertedWideParts

以 Wide 格式插入的 parts 数量。

​

InsertQueriesWithSubqueries

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

​

InsertQuery

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

​

InsertQueryTimeMicroseconds

INSERT 查询耗费的总时间。

​

InterfaceHTTPReceiveBytes

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

​

InterfaceHTTPSendBytes

通过 HTTP 接口发送的字节数

​

InterfaceInterserverReceiveBytes

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

​

InterfaceInterserverSendBytes

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

​

InterfaceMySQLReceiveBytes

通过 MySQL 接口接收的字节数

​

InterfaceMySQLSendBytes

通过 MySQL 接口发送的字节数

​

InterfaceNativeReceiveBytes

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

​

InterfaceNativeSendBytes

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

​

InterfacePostgreSQLReceiveBytes

通过 PostgreSQL 接口接收的字节数

​

InterfacePostgreSQLSendBytes

经 PostgreSQL 接口发送的字节数

​

InterfacePrometheusReceiveBytes

经由 Prometheus 接口接收的字节数

​

InterfacePrometheusSendBytes

通过 Prometheus 接口发送的字节数

​

IOBufferAllocBytes

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

​

IOBufferAllocs

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

​

IOUringCQEsCompleted

成功完成的 io_uring CQE 数量总计

​

IOUringCQEsFailed

已完成但失败的 io_uring CQE 总数

​

IOUringSQEsResubmitsAsync

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

​

IOUringSQEsResubmitsSync

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

​

IOUringSQEsSubmitted

提交的 io_uring SQE 总数

​

JemallocFailedAllocationSampleTracking

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

​

JemallocFailedDeallocationSampleTracking

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

​

JoinBuildPostProcessingMicroseconds

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

​

JoinBuildRowStoreMicroseconds

将 JOIN 右侧载荷转换为行主序格式的耗时。

​

JoinBuildTableRowCount

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

​

JoinDelayedJoinedTransformBlockCount

DelayedJoinedBlocksWorkerTransform 输出的块数。

​

JoinDelayedJoinedTransformRowCount

DelayedJoinedBlocksWorkerTransform 输出的行数。

​

JoinNonJoinedTransformBlockCount

NonJoinedBlocksTransform 输出的块数。

​

JoinNonJoinedTransformRowCount

由 NonJoinedBlocksTransform 输出的未匹配行数。

​

JoinOptimizeMicroseconds

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

​

JoinProbeTableRowCount

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

​

JoinReorderMicroseconds

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

​

JoinResultRowCount

JOIN 操作结果的总行数。

​

JoinSpillingHashJoinSwitchedToGraceJoin

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

​

KafkaBackgroundReads

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

​

KafkaCommitFailures

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

​

KafkaCommits

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

​

KafkaConsumerErrors

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

​

KafkaDirectReads

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

​

KafkaMessagesFailed

ClickHouse 解析失败的 Kafka 消息数

​

KafkaMessagesPolled

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

​

KafkaMessagesProduced

生成到 Kafka 的消息数

​

KafkaMessagesRead

ClickHouse 已处理的 Kafka 消息数

​

KafkaMVNotReady

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

​

KafkaProducerErrors

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

​

KafkaProducerFlushes

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

​

KafkaRebalanceAssignments

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

​

KafkaRebalanceErrors

消费者组再平衡失败次数

​

KafkaRebalanceRevocations

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

​

KafkaRowsRead

从 Kafka 消息中解析的行数

​

KafkaRowsRejected

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

​

KafkaRowsWritten

写入 Kafka 表的行数

​

KafkaWrites

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

​

KeeperAddWatchRequest

添加 watch 的请求数量

​

KeeperBatchMaxCount

达到 max_requests_batch_size 上限的批次数

​

KeeperBatchMaxReadCount

达到 max_read_batch_size 上限的批次数量

​

KeeperBatchMaxReadTotalSize

达到 max_read_batch_bytes_size 限制的批次数量

​

KeeperBatchMaxTotalSize

达到 max_requests_batch_bytes_size 限制的批次数

​

KeeperChangelogFileSyncMicroseconds

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

​

KeeperChangelogLockWaitMicroseconds

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

​

KeeperChangelogStartupReadBytes

并行 Keeper 启动读取器从更新日志文件中读取的物理字节数 (校验和 + 请求头 + blob)

​

KeeperChangelogStartupReadEntries

由 Keeper 并行启动读取器校验的更新日志记录数

​

KeeperChangelogStartupReadMicroseconds

Keeper 启动期间并行读取更新日志所耗费的墙钟时间

​

KeeperChangelogStartupStitchMicroseconds

将各文件并行启动读取的结果拼接为 LogEntryStorage 状态所花费的墙钟时间

​

KeeperChangelogWrittenBytes

写入 Keeper 更新日志的字节数

​

KeeperCheckRequest

检查请求数

​

KeeperCheckWatchRequest

remove watches 请求的数量

​

KeeperCommits

成功提交的次数

​

KeeperCommitsFailed

失败的提交次数

​

KeeperCommitWaitElapsedMicroseconds

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

​

KeeperCreateRequest

创建请求数量

​

KeeperExistsRequest

exists 请求数量

​

KeeperGetRequest

get 请求数量

​

KeeperLatency

Keeper 延迟

​

KeeperListRecursiveRequest

递归获取子节点请求数

​

KeeperListRequest

列表请求数量

​

KeeperLiveSessionsLockWaitMicroseconds

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

​

KeeperLogsEntryReadFromCommitReadAhead

从 commit 预读读取器的已解码窗口中提供给 commit 线程的日志条目数量 (快速路径 pop 或窗口首个元素排空 pop)

​

KeeperLogsEntryReadFromFile

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

​

KeeperLogsEntryReadFromLatestCache

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

​

KeeperLogsReadAheadCursorsInstalled

排入 Keeper 更新日志 预读读取器 (peer 或 commit) 队列、且尚未被 填充任务 覆盖的新 fill 游标数量

​

KeeperLogsReadAheadFillDecodedEntries

由 Keeper 预读填充任务解码的日志条目数

​

KeeperLogsReadAheadFillReopens

Keeper 预读填充重新打开或寻道更新日志文件的次数

​

KeeperLogsReadAheadPlanEpochMismatches

Keeper 更新日志 读取 plan 因并发的 write_at 截断在其生效前使其失效而被丢弃的次数

​

KeeperLogsReadAheadReadersCreated

已创建的 Keeper 更新日志预读读取器 (及其填充任务) 数量；若该值在跨越文件边界时保持不变，说明读取器被复用，而非被销毁后重新创建

​

KeeperLogsReadAheadScheduleRejected

因预读线程池队列已满而无法创建 Keeper 更新日志预读读取器的次数；此时调用方将回退为直接读取

​

KeeperLogsReadAheadTimeoutFallbacks

Keeper 更新日志预读服务请求在等待 填充任务 时超时，转而对剩余尾部内容执行直接读取的次数

​

KeeperLSMTCommittedEntryBytes

追加到 Keeper LSMT 已提交 memtable 的条目的序列化字节数

​

KeeperLSMTCommittedMemtablesCreated

Keeper LSMT 创建的已提交 memtable 数量

​

KeeperLSMTFileDeletionExceptions

Keeper LSMT 文件删除过程中的异常数量

​

KeeperLSMTFlushes

成功完成的 Keeper LSMT memtable 刷写次数

​

KeeperLSMTFlushExceptions

Keeper LSMT memtable 刷写过程中发生的异常次数

​

KeeperLSMTFlushWrittenCompressedBytes

Keeper LSMT memtable 刷写时写入文件的压缩字节数

​

KeeperLSMTFlushWrittenUncompressedBytes

Keeper LSMT memtable 刷写写入文件的未压缩字节数

​

KeeperLSMTGetBlockFromCache

由块缓存响应的 Keeper LSMT 块访问次数

​

KeeperLSMTGetBlockFromWeakPtr

通过文件块信息中的弱指针完成的 Keeper LSMT 块访问次数

​

KeeperLSMTGetBlockLoadedGroup

Keeper LSMT 块访问中需要从磁盘加载块组的次数

​

KeeperLSMTGetCommittedNodeFromMemory

Keeper LSMT 已提交节点查找中，节点所在块已位于内存中的次数

​

KeeperLSMTGetCommittedNodeLoadedBlock

Keeper LSMT 中需要加载节点数据块的已提交节点查找次数

​

KeeperLSMTGetCommittedNodeNonexistent

针对不存在的节点执行的 Keeper LSMT 已提交 node 查找次数

​

KeeperLSMTGetUncommittedNodeHits

在未提交的 memtable 中命中节点的 Keeper LSMT 节点查找次数

​

KeeperLSMTGetUncommittedNodeMisses

Keeper LSMT 节点查找中,未在未提交的 memtable 中找到节点、转而回退到已提交状态查找的次数

​

KeeperLSMTListFilterFalsePositives

未被 Keeper LSMT 父路径过滤器跳过、但最终未找到子节点的文件扫描次数

​

KeeperLSMTListFilterSkipped

因父路径过滤器已排除所有子节点，Keeper LSMT list 操作跳过的文件扫描次数

​

KeeperLSMTListFilterTruePositives

未被 Keeper LSMT 父路径过滤器跳过、且找到了子节点的文件扫描次数

​

KeeperLSMTListNamesFromFiles

Keeper LSMT list 操作从文件中获取的子节点名称 (包括墓碑标记)

​

KeeperLSMTListNamesFromMemtables

Keeper LSMT list 操作从 memtable 中获取的子节点名称 (包括墓碑标记)

​

KeeperLSMTListScannedBlocks

Keeper LSMT list 操作在文件中扫描的块数

​

KeeperLSMTListScannedEntries

Keeper LSMT list 操作在文件中扫描的条目数

​

KeeperLSMTLoadedBlocks

Keeper LSMT 从磁盘加载的块数

​

KeeperLSMTLoadedUncompressedBytes

Keeper LSMT 从磁盘加载的块的未压缩字节数

​

KeeperLSMTMergeConsumedFiles

Keeper LSMT 合并过程中被完全消费并删除的输入文件数

​

KeeperLSMTMergeConsumedUncompressedBytes

被 Keeper LSMT 合并完全消费并删除的输入文件中的未压缩字节数

​

KeeperLSMTMergeExceptions

Keeper LSMT 合并过程中出现的异常数量

​

KeeperLSMTMerges

成功完成的 Keeper LSMT 合并次数

​

KeeperLSMTMergeWrittenCompressedBytes

Keeper LSMT 合并产生的输出文件中的压缩字节数

​

KeeperLSMTMergeWrittenFiles

Keeper LSMT 合并所产生的输出文件数量

​

KeeperLSMTMergeWrittenUncompressedBytes

Keeper LSMT 合并发布的输出文件中的未压缩字节数

​

KeeperLSMTNodeCacheEntriesUpdated

被重新指向新加载块的 Keeper LSMT 节点缓存条目数

​

KeeperLSMTThrottledWrites

因 Keeper LSMT 后台刷写或合并跟不上而被延迟的写入次数

​

KeeperLSMTUncommittedCreateBytes

追加到 Keeper LSMT 未提交 memtable 中的 Create entries 序列化后的字节数

​

KeeperLSMTUncommittedCreates

追加到 Keeper LSMT 未提交 memtable 中的 Create entries 数量

​

KeeperLSMTUncommittedMemtablesCreated

Keeper LSMT 创建的未提交 memtable 数量

​

KeeperLSMTUncommittedRemoveBytes

追加到 Keeper LSMT 未提交 memtable 中的 Remove entries 的序列化字节数

​

KeeperLSMTUncommittedRemoves

追加到 Keeper LSMT 未提交 memtable 中的 Remove entries 数量

​

KeeperLSMTUncommittedUpdateBytes

追加到 Keeper LSMT 未提交 memtable 中的 Update entries 的序列化字节数

​

KeeperLSMTUncommittedUpdates

追加到 Keeper LSMT 未提交 memtable 中的 Update 条目数

​

KeeperMultiReadRequest

多重读取请求数量

​

KeeperMultiRequest

multi 请求数

​

KeeperPacketsReceived

Keeper server 收到的数据包

​

KeeperPacketsSent

Keeper 服务器已发送的数据包

​

KeeperPreprocessElapsedMicroseconds

单个请求的 Keeper 预处理延迟

​

KeeperProcessAndResponsesLockWaitMicroseconds

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

​

KeeperProcessElapsedMicroseconds

单次请求的 Keeper 提交 延迟

​

KeeperReadBatchCount

Keeper 处理的读取请求批次数

​

KeeperReadBatchTotalRequests

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

​

KeeperReadRequestQueueLockWaitMicroseconds

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

​

KeeperReadSnapshot

已完成的快照读取次数

​

KeeperReadSnapshotDeferred

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

​

KeeperReadSnapshotFailed

快照读取失败次数

​

KeeperReadSnapshotObject

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

​

KeeperReconfigRequest

重新配置请求数量

​

KeeperRemoveRequest

删除请求数

​

KeeperRemoveWatchRequest

移除 watch 的请求数量

​

KeeperRequestRejectedDueToSoftMemoryLimitCount

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

​

KeeperRequestTotal

Keeper server 的请求总数

​

KeeperRequestTotalWithSubrequests

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

​

KeeperSaveSnapshot

保存快照的次数

​

KeeperSaveSnapshotFailed

快照保存失败次数

​

KeeperSaveSnapshotObject

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

​

KeeperServerWriteLockWaitMicroseconds

等待获取 Keeper server 写锁的耗时

​

KeeperSessionCallbackLockWaitMicroseconds

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

​

KeeperSetRequest

Set 请求数

​

KeeperSetWatchesRequest

set watches 请求数

​

KeeperSnapshotApplys

应用快照的次数

​

KeeperSnapshotApplysFailed

快照应用失败的次数

​

KeeperSnapshotCreations

快照创建次数

​

KeeperSnapshotCreationsFailed

快照创建失败次数

​

KeeperSnapshotFileSyncMicroseconds

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

​

KeeperSnapshotRemoteLoaderErrors

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

​

KeeperSnapshotWrittenBytes

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

​

KeeperStaleRequestsSkipped

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

​

KeeperStorageLockWaitMicroseconds

等待获取 Keeper 存储锁的时间

​

KeeperStorageSharedLockWaitMicroseconds

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

​

KeeperTotalElapsedMicroseconds

单次请求的 Keeper 总延迟

​

KeeperTTLRemoveRequestsDropped

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

​

KeeperTTLRemoveRequestsEnqueued

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

​

KeeperWatchesTriggered

watch 被触发的次数

​

KeeperWatchTriggeredNodeChildrenChanged

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

​

KeeperWatchTriggeredNodeCreated

由 CREATE 操作触发的 watch 数量

​

KeeperWatchTriggeredNodeDataChanged

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

​

KeeperWatchTriggeredNodeDeleted

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

​

KeeperWriteBatchCount

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

​

KeeperWriteBatchTotalRequests

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

​

LoadedDataParts

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

​

LoadedDataPartsMicroseconds

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

​

已加载标记数

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

​

LoadedMarksFiles

已加载的标记文件数。

​

LoadedMarksMemoryBytes

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

​

LoadedPrimaryIndexBytes

已加载的主键行数。

​

LoadedPrimaryIndexFiles

已加载的主索引文件数。

​

LoadedPrimaryIndexRows

已加载的主键行数。

​

LoadedStatisticsMicroseconds

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

​

LoadingMarksTasksCanceled

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

​

LocalReadThrottlerBytes

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

​

LocalReadThrottlerSleepMicroseconds

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

​

LocalThreadPoolBusyMicroseconds

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

​

LocalThreadPoolExpansions

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

​

LocalThreadPoolJobs

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

​

LocalThreadPoolJobWaitTimeMicroseconds

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

​

LocalThreadPoolLockWaitMicroseconds

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

​

LocalThreadPoolShrinks

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

​

LocalThreadPoolThreadCreationMicroseconds

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

​

LocalWriteThrottlerBytes

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

​

LocalWriteThrottlerSleepMicroseconds

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

​

LogDebug

Debug 级别的日志消息数量

​

LogError

Error 级别的日志消息数量

​

LogFatal

Fatal 级别的日志消息数量

​

LoggerElapsedNanoseconds

日志记录的累计耗时

​

LogInfo

Info 级别日志消息的数量

​

LogTest

Test 级别的日志消息数量

​

LogTrace

Trace 级别的日志消息数量

​

LogWarning

警告级别的日志消息数量

​

MainConfigLoads

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

​

MarkCacheEvictedBytes

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

​

MarkCacheEvictedFiles

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

​

MarkCacheEvictedMarks

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

​

MarkCacheHits

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

​

MarkCacheMisses

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

​

MarksTasksFromCache

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

​

MemoryAllocatedWithoutCheck

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

​

MemoryAllocatedWithoutCheckBytes

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

​

MemoryAllocatorPurge

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

​

MemoryAllocatorPurgeTimeMicroseconds

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

​

MemoryOvercommitWaitTimeMicroseconds

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

​

MemoryReservationAdmitMicroseconds

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

​

MemoryReservationDecreases

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

​

MemoryReservationFailed

内存预留失败总数

​

MemoryReservationIncreaseMicroseconds

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

​

MemoryReservationIncreases

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

​

MemoryReservationKilled

内存预留终止信号的总数

​

MemoryWorkerRun

MemoryWorker 在后台执行的次数

​

MemoryWorkerRunElapsedMicroseconds

MemoryWorker 执行后台工作的总耗时

​

合并

已启动的后台合并次数。

​

MergeCommitMilliseconds

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

​

MergedColumns

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

​

MergedIntoCompactParts

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

​

MergedIntoWideParts

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

​

MergedProjections

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

​

MergedRows

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

​

MergedUncompressedBytes

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

​

MergeExecuteMilliseconds

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

​

MergeHorizontalStageExecuteMilliseconds

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

​

MergeHorizontalStageTotalMilliseconds

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

​

MergeMutateBackgroundExecutorTaskCancelMicroseconds

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

​

MergeMutateBackgroundExecutorTaskExecuteStepMicroseconds

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

​

MergeMutateBackgroundExecutorTaskResetMicroseconds

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

​

MergeMutateBackgroundExecutorWaitMicroseconds

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

​

MergePrewarmStageExecuteMilliseconds

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

​

MergePrewarmStageTotalMilliseconds

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

​

MergeProjectionStageExecuteMilliseconds

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

​

MergeProjectionStageTotalMilliseconds

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

​

MergerMutatorPartsInRangesForMergeCount

可供 合并 的候选 parts 数量

​

MergerMutatorPrepareRangesForMergeElapsedMicroseconds

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

​

MergerMutatorRangesForMergeCount

用于合并的候选范围数量

​

MergerMutatorSelectPartsForMergeElapsedMicroseconds

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

​

MergerMutatorSelectRangePartsCount

所选合并范围内的 parts 数量

​

MergerMutatorsGetPartsForMergeElapsedMicroseconds

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

​

MergeSourceParts

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

​

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

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

​

MergesThrottlerBytes

通过 ‘max_merges_bandwidth_for_server’ 限流器的字节数。

​

MergesThrottlerSleepMicroseconds

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

​

MergeTextIndexStageExecuteMilliseconds

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

​

MergeTextIndexStageTotalMilliseconds

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

​

MergeTotalMilliseconds

后台合并耗费的总时间

​

MergeTreeAllRangesAnnouncementsSent

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

​

MergeTreeAllRangesAnnouncementsSentElapsedMicroseconds

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

​

MergeTreeDataProjectionWriterBlocks

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

​

MergeTreeDataProjectionWriterBlocksAlreadySorted

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

​

MergeTreeDataProjectionWriterCompressedBytes

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

​

MergeTreeDataProjectionWriterMergingBlocksMicroseconds

合并块所耗费的时间

​

MergeTreeDataProjectionWriterRows

INSERT 到 MergeTree 表投影的行数。

​

MergeTreeDataProjectionWriterSortingBlocksMicroseconds

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

​

MergeTreeDataProjectionWriterUncompressedBytes

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

​

MergeTreeDataWriterBlocks

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

​

MergeTreeDataWriterBlocksAlreadySorted

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

​

MergeTreeDataWriterCompressedBytes

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

​

MergeTreeDataWriterMergingBlocksMicroseconds

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

​

MergeTreeDataWriterProjectionsCalculationMicroseconds

计算 投影 所花费的时间

​

MergeTreeDataWriterRows

插入到 MergeTree 表中的行数。

​

MergeTreeDataWriterSkipIndicesCalculationMicroseconds

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

​

MergeTreeDataWriterSortingBlocksMicroseconds

块排序耗时

​

MergeTreeDataWriterStatisticsCalculationMicroseconds

计算统计信息的耗时

​

MergeTreeDataWriterUncompressedBytes

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

​

MergeTreePrefetchedReadPoolInit

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

​

MergeTreeReadTaskRequestsReceived

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

​

MergeTreeReadTaskRequestsSent

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

​

MergeTreeReadTaskRequestsSentElapsedMicroseconds

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

​

MergeVerticalStageExecuteMilliseconds

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

​

MergeVerticalStageTotalMilliseconds

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

​

MergeWrittenRows

合并期间写入的行数。

​

MergingSortedMilliseconds

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

​

MetadataFromKeeperBackgroundCleanupBlobs

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

​

MetadataFromKeeperBackgroundCleanupErrors

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

​

MetadataFromKeeperBackgroundCleanupObjects

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

​

MetadataFromKeeperBackgroundCleanupTransactions

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

​

MetadataFromKeeperCacheHit

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

​

MetadataFromKeeperCacheMiss

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

​

MetadataFromKeeperCacheTooManyInvalidated

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

​

MetadataFromKeeperCacheUpdateMicroseconds

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

​

MetadataFromKeeperCleanupTransactionCommit

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

​

MetadataFromKeeperCleanupTransactionCommitRetry

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

​

MetadataFromKeeperIndividualOperations

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

​

MetadataFromKeeperIndividualOperationsMicroseconds

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

​

MetadataFromKeeperOperations

向 Keeper 发起请求的次数

​

MetadataFromKeeperReconnects

重连 Keeper 的次数

​

MetadataFromKeeperTransactionCommit

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

​

MetadataFromKeeperTransactionCommitRetry

元数据事务提交重试次数

​

MetadataFromKeeperUpdateCacheOneLevel

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

​

MetadataTransactionRollbacks

提交失败并被回滚的元数据事务数量。

​

MetadataTransactionRollbacksFailed

未执行完成的元数据事务回滚次数，导致元数据中仍残留着已被报告为失败的事务的一部分。

​

MMappedFileCacheHits

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

​

MMappedFileCacheMisses

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

​

MoveBackgroundExecutorTaskCancelMicroseconds

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

​

MoveBackgroundExecutorTaskExecuteStepMicroseconds

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

​

MoveBackgroundExecutorTaskResetMicroseconds

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

​

MoveBackgroundExecutorWaitMicroseconds

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

​

MutatedRows

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

​

MutatedUncompressedBytes

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

​

MutateTaskProjectionsCalculationMicroseconds

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

​

MutationAffectedRowsUpperBound

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

​

MutationAllPartColumns

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

​

MutationCommitMilliseconds

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

​

MutationCreatedEmptyParts

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

​

MutationExecuteMilliseconds

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

​

MutationsAppliedOnFlyInAllReadTasks

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

​

MutationSomePartColumns

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

​

MutationsThrottlerBytes

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

​

MutationsThrottlerSleepMicroseconds

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

​

MutationTotalMilliseconds

变更耗费的总时间。

​

MutationTotalParts

尝试应用变更的 parts 总数

​

MutationUntouchedParts

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

​

NativeProtocolSend

非空原生协议输出缓冲区的刷写次数。

​

NetworkReceiveBytes

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

​

NetworkReceiveElapsedMicroseconds

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

​

NetworkSendBytes

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

​

NetworkSendElapsedMicroseconds

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

​

NotCreatedLogEntryForMerge

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

​

NotCreatedLogEntryForMutation

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

​

ObjectStorageGlobFilteredObjects

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

​

ObjectStorageListedObjects

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

​

ObjectStoragePredicateFilteredObjects

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

​

ObjectStorageQueueBucketLockLostOwnership

在 S3(Azure)Queue 中检测到 桶锁 所有权丢失的次数。非零值表示 persistent_processing_node_ttl_seconds 设置过小，或存在 bug

​

ObjectStorageQueueBucketLockRefreshes

S3(Azure)Queue 中成功刷新桶锁的次数

​

ObjectStorageQueueCancelledFiles

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

​

ObjectStorageQueueCleanupMaxSetSizeOrTTLMicroseconds

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

​

ObjectStorageQueueCommitRequests

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

​

ObjectStorageQueueExceptionsDuringInsert

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

​

ObjectStorageQueueExceptionsDuringRead

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

​

ObjectStorageQueueExclusiveModeProcessingErrors

S3(Azure)Queue 中的文件因处理错误而未能最终确定状态的次数。仅适用于 ‘exclusive’ 模式。

​

ObjectStorageQueueFailedFiles

处理失败的文件数

​

ObjectStorageQueueFailedToBatchSetProcessing

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

​

ObjectStorageQueueFilteredFiles

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

​

ObjectStorageQueueInsertIterations

插入迭代次数

​

ObjectStorageQueueListedFiles

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

​

ObjectStorageQueueMovedObjects

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

​

ObjectStorageQueueProcessedFiles

已处理文件数量

​

ObjectStorageQueueProcessedRows

StorageS3(Azure)Queue 中已处理行数

​

ObjectStorageQueuePullMicroseconds

读取文件数据耗费的时间

​

ObjectStorageQueueReadBytes

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

​

ObjectStorageQueueReadFiles

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

​

ObjectStorageQueueReadRows

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

​

ObjectStorageQueueRemovedObjects

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

​

ObjectStorageQueueRemoveObjectFailures

在 after_processing = delete 过程中删除失败的对象数量

​

ObjectStorageQueueSuccessfulCommits

成功的 Keeper 提交数

​

ObjectStorageQueueTaggedObjects

被标记为 after_processing = tag 的对象数

​

ObjectStorageQueueTrySetProcessingFailed

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

​

ObjectStorageQueueTrySetProcessingRequests

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

​

ObjectStorageQueueTrySetProcessingSucceeded

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

​

ObjectStorageQueueUnsuccessfulCommits

Keeper 提交失败次数

​

ObjectStorageReadObjects

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

​

ObsoleteReplicatedParts

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

​

OneLakeAccessTokenExpirations

检测到缓存的 OneLake 访问令牌已过期并被透明续期的次数。

​

OneLakeAccessTokenRequestFailures

OneLake catalog 通过 Entra ID refresh token 授权发起的 访问令牌 请求失败次数 (包括 refresh token 已过期或已被撤销的情况) 。

​

OneLakeAccessTokenRequestMicroseconds

在 OneLake catalog 中通过 Entra ID refresh token 授权方式请求 访问令牌 所耗费的总时间。

​

OneLakeAccessTokenRequests

OneLake catalog 通过 Entra ID refresh token 授权发起的访问令牌请求数。

​

OpenedFileCacheHits

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

​

OpenedFileCacheMicroseconds

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

​

OpenedFileCacheMisses

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

​

OSCPUVirtualTimeMicroseconds

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

​

OSCPUWaitMicroseconds

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

​

OSIOWaitMicroseconds

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

​

OSReadBytes

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

​

OSReadChars

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

​

OSWriteBytes

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

​

OSWriteChars

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

​

OtherQueryTimeMicroseconds

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

​

OverflowAny

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

​

OverflowBreak

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

​

OverflowThrow

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

​

PageCacheHits

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

​

PageCacheMisses

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

​

PageCacheOvercommitResize

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

​

PageCacheReadBytes

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

​

PageCacheResized

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

​

PageCacheWeightLost

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

​

PaimonMetadataFilesCacheHits

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

​

PaimonMetadataFilesCacheMisses

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

​

PaimonMetadataFilesCacheWeightLost

从 paimon 元数据缓存中逐出的大致字节数。

​

ParallelReplicasAnnouncementMicroseconds

发送通知耗费的时间

​

ParallelReplicasAvailableCount

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

​

ParallelReplicasCollectingOwnedSegmentsMicroseconds

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

​

ParallelReplicasDeniedRequests

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

​

ParallelReplicasHandleAnnouncementMicroseconds

处理副本通知所用的时间

​

ParallelReplicasHandleRequestMicroseconds

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

​

ParallelReplicasNumRequests

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

​

ParallelReplicasProcessingPartsMicroseconds

处理数据分区片段耗时

​

ParallelReplicasQueryCount

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

​

ParallelReplicasReadAssignedForStealingMarks

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

​

ParallelReplicasReadAssignedMarks

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

​

ParallelReplicasReadMarks

给定副本读取的标记数

​

ParallelReplicasReadRequestMicroseconds

读取请求耗时

​

ParallelReplicasReadUnassignedMarks

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

​

ParallelReplicasStealingByHashMicroseconds

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

​

ParallelReplicasStealingLeftoversMicroseconds

收集遗留分段所用的时间

​

ParallelReplicasUnavailableCount

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

​

ParallelReplicasUsedCount

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

​

ParquetColumnsFilterExpression

经过过滤器的列总数

​

ParquetDecodingTaskBatches

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

​

ParquetDecodingTasks

由 Parquet 读取器 发起的任务

​

ParquetFetchWaitTimeMicroseconds

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

​

ParquetMetadataCacheHits

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

​

ParquetMetadataCacheMisses

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

​

ParquetMetadataCacheWeightLost

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

​

ParquetPrefetcherReadEntireFile

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

​

ParquetPrefetcherReadRandomRead

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

​

ParquetPrefetcherReadSeekAndRead

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

​

ParquetPrunedPages

借助列索引从 Parquet 数据中裁剪掉的数据页总数

​

ParquetPrunedRowGroups

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

​

ParquetReadPages

读取的 Parquet 数据页总数

​

ParquetReadRowGroups

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

​

ParquetRowsFilterExpression

经过过滤器的总行数

​

PartsLockHoldMicroseconds

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

​

PartsLocks

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

​

PartsLockWaitMicroseconds

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

​

PatchesAcquireLockBadVersionRetries

因并发的 update 先行 commit，导致为轻量级更新获取 锁 时所进行的 retries 总次数

​

PatchesAcquireLockMicroseconds

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

​

PatchesAcquireLockTries

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

​

PatchesAppliedInAllReadTasks

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

​

PatchesJoinAppliedInAllReadTasks

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

​

PatchesJoinRowsAddedToHashTable

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

​

PatchesMergeAppliedInAllReadTasks

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

​

PatchesMergeOnKeyAppliedInAllReadTasks

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

​

PatchesReadRows

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

​

PatchesReadUncompressedBytes

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

​

PerfAlignmentFaults

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

​

PerfBranchInstructions

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

​

PerfBranchMisses

被错误预测的分支指令。

​

PerfBusCycles

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

​

PerfCacheMisses

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

​

PerfCacheReferences

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

​

PerfContextSwitches

上下文切换次数

​

PerfCPUClock

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

​

PerfCPUCycles

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

​

PerfCPUMigrations

进程迁移到其他 CPU 的次数

​

PerfDataTLBMisses

数据 TLB 未命中

​

PerfDataTLBReferences

数据 TLB 引用次数

​

PerfEmulationFaults

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

​

PerfInstructions

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

​

PerfInstructionTLBMisses

指令 TLB 未命中

​

PerfInstructionTLBReferences

指令 TLB 访问

​

PerfLocalMemoryMisses

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

​

PerfLocalMemoryReferences

本地 NUMA 节点内存读操作

​

PerfMinEnabledRunningTime

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

​

PerfMinEnabledTime

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

​

PerfRefCPUCycles

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

​

PerfStalledCyclesBackend

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

​

PerfStalledCyclesFrontend

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

​

PerfTaskClock

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

​

首选已预热的未合并 parts

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

​

PrimaryIndexCacheHits

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

​

PrimaryIndexCacheMisses

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

​

包含子查询的查询

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

​

查询

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

​

QueryAnalysisMicroseconds

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

​

QueryBackupThrottlerBytes

通过 ‘max_backup_bandwidth’ 限流器的字节数。

​

QueryBackupThrottlerSleepMicroseconds

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

​

QueryCacheAgeSeconds

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

​

QueryCacheHits

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

​

QueryCacheMisses

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

​

QueryCacheReadBytes

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

​

QueryCacheReadRows

从查询缓存读取的行数。

​

QueryCacheWrittenBytes

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

​

QueryCacheWrittenRows

写入查询缓存的行数。

​

QueryConditionCacheHits

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

​

QueryConditionCacheMisses

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

​

QueryLocalReadThrottlerBytes

通过 max_local_read_bandwidth 限流器的字节数。

​

QueryLocalReadThrottlerSleepMicroseconds

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

​

QueryLocalWriteThrottlerBytes

通过 max_local_write_bandwidth 限流器的字节数。

​

QueryLocalWriteThrottlerSleepMicroseconds

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

​

QueryMaskingRulesMatch

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

​

QueryMemoryLimitExceeded

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

​

QueryParseMicroseconds

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

​

QueryPipelineBuildMicroseconds

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

​

QueryPlanBuildMicroseconds

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

​

QueryPlanOptimizeMicroseconds

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

​

QueryPreempted

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

​

QueryProfilerConcurrencyOverruns

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

​

QueryProfilerErrors

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

​

QueryProfilerRuns

QueryProfiler 的运行次数。

​

QueryProfilerSignalOverruns

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

​

QueryRemoteReadThrottlerBytes

经过 ‘max_remote_read_network_bandwidth’ 限流器的字节数。

​

QueryRemoteReadThrottlerSleepMicroseconds

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

​

QueryRemoteWriteThrottlerBytes

经过 max_remote_write_network_bandwidth 限流器的字节数。

​

QueryRemoteWriteThrottlerSleepMicroseconds

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

​

QueryTimeMicroseconds

所有查询耗费的总时间。

​

QuorumFailedInserts

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

​

QuorumParts

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

​

QuorumWaitMicroseconds

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

​

QuotaCacheRecalculationMicroseconds

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

​

配额缓存重新计算

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

​

ReadBackoff

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

​

ReadBufferFromAzureBytes

从 Azure 读取的字节数。

​

ReadBufferFromAzureInitMicroseconds

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

​

ReadBufferFromAzureMicroseconds

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

​

ReadBufferFromAzureRequestsErrors

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

​

ReadBufferFromFileDescriptorRead

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

​

ReadBufferFromFileDescriptorReadBytes

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

​

ReadBufferFromFileDescriptorReadFailed

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

​

ReadBufferFromS3Bytes

从 S3 读取的字节数。

​

ReadBufferFromS3InitMicroseconds

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

​

ReadBufferFromS3Microseconds

从 S3 读取耗费的时间。

​

ReadBufferFromS3RequestsErrors

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

​

ReadBufferSeekCancelConnection

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

​

ReadCompressedBytes

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

​

ReaderExecutorBytesFromSource

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

​

ReaderExecutorCacheGetRequests

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

​

ReaderExecutorCachePopulateRequests

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

​

ReaderExecutorDecryptMicroseconds

ReaderExecutor 就地解密所返回载荷 (CTR，可按位置寻址) 所耗费的时间。未加密的读取以及未启用 SSL 的构建中该值为零。

​

ReaderExecutorDeliveredBytes

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

​

ReaderExecutorIncompleteConnections

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

​

ReaderExecutorLongConnectionBytes

通过 long 源连接 读取的总字节数。

​

ReaderExecutorLongConnectionFallbacks

ReaderExecutor 需要使用 long 源连接，但由于没有可用的 slot 而回退为一次性读取的次数。

​

ReaderExecutorLongConnectionHits

ReaderExecutor 通过从已打开的 long 源连接 读取来处理的 窗口 数量。

​

ReaderExecutorLongConnectionOpened

ReaderExecutor 为顺序读取优化而打开的 long 源连接 数量。

​

ReaderExecutorModeledCostMicroseconds

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

​

ReaderExecutorSourceRequests

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

​

ReaderExecutorWorkMicroseconds

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

​

ReadPatchesMicroseconds

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

​

ReadPoolRangeRefinerDroppedCuts

MergeTree read pool 从某个 part 中切分出的 ranges 被 ranges refiner 完全丢弃，从而没有为其创建读取任务的次数

​

ReadPoolRangeRefinerDroppedMarks

在 MergeTree 读取池中，ranges refiner 从读取任务中丢弃的标记数量 (例如被 projection index 完全过滤掉的标记)

​

ReadTaskRequestsReceived

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

​

ReadTaskRequestsSent

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

​

ReadTaskRequestsSentElapsedMicroseconds

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

​

ReadTasksWithAppliedMutationsOnFly

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

​

ReadTasksWithAppliedPatches

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

​

ReadWriteBufferFromHTTPBytes

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

​

ReadWriteBufferFromHTTPRequestsSent

ReadWriteBufferFromHTTP 发出的 HTTP 请求数

​

RealTimeMicroseconds

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

​

RebuiltProjections

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

​

RefreshableViewLockTableRetry

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

​

RefreshableViewRefreshFailed

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

​

RefreshableViewRefreshSuccess

可刷新materialized view 的刷新次数

​

RefreshableViewSyncReplicaRetry

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

​

RefreshableViewSyncReplicaSuccess

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

​

RegexpLocalCacheHit

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

​

RegexpLocalCacheMiss

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

​

RegexpWithMultipleNeedlesCreated

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

​

RegexpWithMultipleNeedlesGlobalCacheHit

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

​

RegexpWithMultipleNeedlesGlobalCacheMiss

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

​

RejectedInserts

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

​

RejectedLightweightUpdates

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

​

RejectedMutations

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

​

RemoteFSBuffers

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

​

RemoteFSCancelledPrefetches

因寻道而取消的预取次数

​

RemoteFSLazySeeks

惰性寻道次数

​

RemoteFSPrefetchedBytes

预取缓冲区中的字节数

​

RemoteFSPrefetchedReads

从预取缓冲区读取的次数

​

RemoteFSPrefetches

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

​

RemoteFSSeeks

异步缓冲区寻道总次数

​

RemoteFSSeeksWithReset

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

​

RemoteFSUnprefetchedBytes

未预取缓冲区中的字节数

​

RemoteFSUnprefetchedReads

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

​

RemoteFSUnusedPrefetches

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

​

RemoteReadThrottlerBytes

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

​

RemoteReadThrottlerSleepMicroseconds

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

​

RemoteWriteThrottlerBytes

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

​

RemoteWriteThrottlerSleepMicroseconds

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

​

ReplacingSortedMilliseconds

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

​

ReplicaPartialShutdown

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

​

ReplicatedCoveredPartsInZooKeeperOnStart

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

​

ReplicatedDataLoss

所需数据分区片段在任何副本上都不存在 (包括当前离线的副本) 时的次数。这些数据分区片段可以确定已经丢失。在异步复制场景下，这属于正常现象 (如果未启用 quorum 插入) ：当写入该数据分区片段的副本发生故障，并在故障后重新上线时，它将不会包含该数据分区片段。

​

ReplicatedPartChecks

为了在副本上查找某个数据分区片段，或确认是否需要某个现有数据分区片段而必须执行高级搜索的次数。

​

ReplicatedPartChecksFailed

在副本上对数据分区片段进行高级搜索但未找到结果，或发现异常的数据分区片段并将其移走的次数。

​

ReplicatedPartFailedFetches

从 ReplicatedMergeTree 表的副本拉取数据分区片段失败的次数。

​

ReplicatedPartFetches

从 ReplicatedMergeTree 表的副本拉取数据分区片段的次数。

​

ReplicatedPartFetchesOfMerged

表示我们选择从 ReplicatedMergeTree 表的副本拉取已合并的数据分区片段、而不是自行执行合并的次数 (通常为了节省网络流量，我们更倾向于自行合并) 。出现这种情况通常是因为我们缺少执行合并所需的全部源 parts，或者该数据分区片段已经足够旧。

​

ReplicatedPartMerges

ReplicatedMergeTree 表中的数据分区片段成功合并的次数。

​

ReplicatedPartMutations

ReplicatedMergeTree 表中的数据分区片段成功完成变更的次数。

​

RestorePartsSkippedBytes

恢复 parts 时被跳过的文件总大小

​

RestorePartsSkippedFiles

恢复 parts 过程中跳过的文件数

​

RoleCacheRecalculationMicroseconds

重新计算所有当前生效的活动 角色 集合所耗费的总时间 (在持有缓存 互斥锁 的情况下，ContextAccess 的构建路径也会获取该 互斥锁) 。

​

RoleCacheRecalculations

角色缓存重新计算所有当前生效的已启用集合的次数。每个访问实体通知批次最多只会合并为一次。

​

RowPolicyCacheRecalculationMicroseconds

为所有当前生效的已启用集合重新组合行策略过滤器所花费的总时间，该过程在 RowPolicyCache 互斥锁之外进行 (因此不会阻塞 ContextAccess 的构建路径) 。

​

RowPolicyCacheRecalculations

行策略缓存为所有当前有效且已启用的集合重新组合过滤器的次数。按访问实体通知批次合并计算，每个批次最多一次。

​

RowsReadByMainReader

主读取器从 MergeTree 表中读取的行数 (在 PREWHERE 步骤之后) 。

​

RowsReadByPrewhereReaders

prewhere 读取器从 MergeTree 表中总共读取的行数。

​

RuntimeDataflowStatisticsInputBytes

统计信息：如果查询以并行副本方式执行，各副本将读取的字节数

​

RuntimeDataflowStatisticsOutputBytes

统计在使用并行副本执行查询时，副本将发送给发起节点的字节数

​

RuntimeFilterBlocksProcessed

经 JOIN 运行时过滤器 处理的块数

​

RuntimeFilterBlocksSkipped

由于过滤效果较差，过滤器被动态禁用，因此 JOIN 运行时过滤器 未经处理而跳过的块数

​

RuntimeFilterBloomFilterBuildsSkipped

被跳过的 JOIN 运行时过滤器 Bloom filter 构建次数：根据哈希表统计信息得出的构建端 key 数量预测该过滤器的置位比例会超过最大值，因此跳过构建

​

RuntimeFilterGranulesConsidered

JOIN 运行时过滤器为进行读取时裁剪而检查的粒度数

​

RuntimeFilterGranulesDropped

读取时被 JOIN 运行时过滤器裁剪掉的粒度数量

​

RuntimeFilterRowsChecked

经 JOIN 运行时过滤器 检查的行数

​

RuntimeFilterRowsPassed

通过 JOIN 运行时过滤器的行数 (即未被其过滤掉)

​

RuntimeFilterRowsSkipped

因 JOIN 运行时过滤器 而被跳过的块中的行数

​

RuntimeFiltersCreated

单次查询中创建的不同 JOIN 运行时过滤器 数量

​

RWLockAcquiredReadLocks

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

​

RWLockAcquiredWriteLocks

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

​

RWLockReadersWaitMilliseconds

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

​

RWLockWritersWaitMilliseconds

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

​

S3AbortMultipartUpload

S3 API AbortMultipartUpload 调用次数。

​

S3CachedCredentialsProvidersAdded

添加到缓存中的新凭证提供商总数

​

S3CachedCredentialsProvidersReused

从缓存中复用的凭证提供程序总数

​

S3Clients

已创建的 S3 客户端数。

​

S3CompleteMultipartUpload

S3 API CompleteMultipartUpload 的调用次数。

​

S3CopyObject

S3 API 的 CopyObject 调用次数。

​

S3CreateMultipartUpload

S3 API 的 CreateMultipartUpload 调用次数。

​

S3DeleteObjects

S3 API DeleteObject(s) 的调用次数。

​

S3GetObject

S3 API GetObject 调用的次数。

​

S3GetObjectTagging

S3 API 的 GetObjectTagging 调用次数。

​

S3GetRequestThrottlerBlocked

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

​

S3GetRequestThrottlerCount

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

​

S3GetRequestThrottlerSleepMicroseconds

查询为满足 S3 GET 和 SELECT 请求限流要求而休眠的总时长。

​

S3HeadObject

S3 API HeadObject 调用的次数。

​

S3ListObjects

S3 API 的 ListObjects 调用次数。

​

S3PutObject

S3 API 的 PutObject 调用次数。

​

S3PutRequestThrottlerBlocked

被限流器拦截的 S3 PUT、COPY、POST 和 LIST 请求数。

​

S3PutRequestThrottlerCount

通过限流器的 S3 PUT、COPY、POST 和 LIST 请求数量：包括被阻止和未被阻止的请求。

​

S3PutRequestThrottlerSleepMicroseconds

查询因遵守 S3 PUT、COPY、POST 和 LIST 请求限流而休眠的总时长。

​

S3QueueSetFileFailedMicroseconds

将文件设置为失败状态所花费的时间

​

S3QueueSetFileProcessedMicroseconds

将文件设为已处理状态所花费的时间

​

S3QueueSetFileProcessingMicroseconds

将文件设为处理中状态所花费的时间

​

S3ReadMicroseconds

对 S3 存储发起 GET 和 HEAD 请求所耗费的时间。

​

S3ReadRequestAttempts

GET 和 HEAD 请求的尝试次数，包括首次尝试和任何重试，但不包括由 S3 重试策略在内部执行的重试

​

S3ReadRequestRetryableErrors

GET 和 HEAD 请求中可重试错误的数量，不包括由 S3 重试策略在内部执行的重试

​

S3ReadRequestsCount

发往 S3 存储的 GET 和 HEAD 请求数。

​

S3ReadRequestsErrors

S3 存储的 GET 和 HEAD 请求中的非限流错误数。

​

S3ReadRequestsRedirects

对 S3 存储发起的 GET 和 HEAD 请求中的重定向次数。

​

S3ReadRequestsThrottling

对 S3 存储执行 GET 和 HEAD 请求时出现的 429 和 503 错误数量。

​

S3UploadPart

S3 API UploadPart 调用的次数。

​

S3UploadPartCopy

S3 API UploadPartCopy 调用次数。

​

S3WriteMicroseconds

向 S3 存储发送 POST、DELETE、PUT 和 PATCH 请求所花费的时间。

​

S3WriteRequestAttempts

POST、DELETE、PUT 和 PATCH 请求的尝试总次数，包括首次尝试和任何重试，但不包括由重试策略在内部执行的重试

​

S3WriteRequestRetryableErrors

POST、DELETE、PUT 和 PATCH 请求中可重试错误的数量，不包括由重试策略内部执行的重试

​

S3WriteRequestsCount

向 S3 存储发出的 POST、DELETE、PUT 和 PATCH 请求数。

​

S3WriteRequestsErrors

向 S3 存储发出的 POST、DELETE、PUT 和 PATCH 请求中，非限流错误的数量。

​

S3WriteRequestsRedirects

对 S3 存储发起的 POST、DELETE、PUT 和 PATCH 请求的重定向次数。

​

S3WriteRequestsThrottling

向 S3 存储发起 POST、DELETE、PUT 和 PATCH 请求时返回的 429 和 503 错误数。

​

ScalarSubqueriesCacheMiss

从标量子查询读取时缓存未命中，因此必须完整计算的次数

​

ScalarSubqueriesGlobalCacheHit

使用全局缓存读取标量子查询的次数

​

ScalarSubqueriesLocalCacheHit

从标量子查询读取并使用本地缓存的次数

​

SchedulerIOReadBytes

经由调度器进行 IO 读取的字节数。

​

SchedulerIOReadRequests

经调度器处理的 IO 读请求资源请求。

​

SchedulerIOReadWaitMicroseconds

查询因等待 IO 读取资源请求而花费的总时间。

​

SchedulerIOWriteBytes

通过调度器执行 IO 写入时传输的字节数。

​

SchedulerIOWriteRequests

经由调度器传递的 IO 写入资源请求。

​

SchedulerIOWriteWaitMicroseconds

查询等待 IO 写入资源请求的总时长。

​

SchemaInferenceCacheEvictions

缓存中的 schema 因溢出而被淘汰的次数

​

SchemaInferenceCacheHits

在 schema 缓存中命中所请求 source 的次数

​

SchemaInferenceCacheInvalidations

因数据发生变化而导致缓存中的 schema 失效的次数

​

SchemaInferenceCacheMisses

请求的数据源未命中 schema 缓存的次数

​

SchemaInferenceCacheNumRowsHits

从文件统计时，在 schema 缓存中命中行数的次数

​

SchemaInferenceCacheNumRowsMisses

请求的源已在缓存中，但从文件进行计数时，行数不在缓存中的次数

​

SchemaInferenceCacheSchemaHits

schema 推断 期间在 schema 缓存中找到 schema 的次数

​

SchemaInferenceCacheSchemaMisses

schema 推断期间，请求的 source 在缓存中但 schema 不在缓存中的次数

​

寻道

调用 ‘lseek’ 函数的次数。

​

SelectedBytes

从所有表中 SELECT 的字节数 (未压缩；对于列，按其在内存中的存储形式计算) 。

​

SelectedMarks

从 MergeTree 表中选择读取的标记数 (索引粒度) 。

​

SelectedMarksTotal

在从 MergeTree 表中确定要读取哪些标记之前的标记总数 (索引粒度) 。

​

SelectedParts

从 MergeTree 表中选取并读取的数据分区片段数量。

​

SelectedPartsTotal

在从 MergeTree 表中选择要读取哪些数据分区片段之前，数据分区片段的总数。

​

SelectedRanges

从 MergeTree 表中选中读取的所有数据分区片段中 (非相邻) 区间的数量。

​

SelectedRows

从所有表中 SELECT 的行数。

​

SelectivityEstimatorInSetEstimatedFromSize

由于 set 超出 statistics_max_set_size_for_exact_selectivity_estimation，其选择性是根据 set 的大小和范围估算得出、而非基于精确区间的 IN 条件数量

​

SelectivityEstimatorInSetNotBuilt

选择性估算器无法分析的 IN 条件数量，原因是对应的 Set 尚未构建，而估算器又不能执行子查询来填充它

​

使用主键的 SELECT 查询数

统计使用主键来判断 WHERE 条件的 SELECT 查询数量

​

含子查询的 SELECT 查询

统计 SELECT 查询及其所有子查询的数量

​

SelectQuery

与 Query 相同，但仅用于 SELECT 查询。

​

SelectQueryTimeMicroseconds

SELECT 查询的总耗时。

​

SelfDuplicatedAsyncInserts

插入到 ReplicatedMergeTree 表的块中，被系统自行去重的异步插入数量。

​

ServerStartupMilliseconds

从服务器启动到开始监听套接字的耗时 (以毫秒为单位)

​

SetsBuiltFromSubquery

通过运行子查询填充的 IN/JOIN Set 数量。从预构建 Set 缓存中获取的 Set，以及已构建并被复用的 Set，不计入此项。

​

SettingsProfileCacheRecalculationMicroseconds

为所有当前生效且已启用的集合重新合并设置和约束所耗费的总时间 (在持有 cache 互斥锁 期间，ContextAccess 的 build 路径也会获取该 互斥锁) 。

​

SettingsProfileCacheRecalculations

settings profile 缓存在为所有当前活动且已启用的集合重新合并设置和约束时的次数。每个访问实体通知批次合并计为一次。

​

分片

查询中涉及的分片数量，按所有分布式表和表函数汇总计算。如果同一主机出现在多个表中，则会被重复计数。该数值表示预期的分片总数，其中也包括在 skip_unavailable_shards 设置下被跳过的分片。

​

SharedCatalogStateFetchFullFallback

Shared Catalog 状态的增量拉取连续失败次数过多，转而执行完整状态拉取的次数

​

SharedDatabaseCatalogFailedToApplyState

SharedDatabaseCatalog 中应用新状态失败的次数

​

SharedDatabaseCatalogStateApplicationMicroseconds

在 SharedDatabaseCatalog 中应用新状态的总耗时

​

SharedMergeTreeBlobRefCounterSharedBlobs

有多少数据 blob 在 SharedMergeTree blob-list parts 之间按路径共享 (引用计数增量先在 commit 事务中暂存，随后按每个计数器节点汇总为一次 update)

​

SharedMergeTreeBlobsListBlobsWritten

在 SharedMergeTree 的 blobs.list Map 中共记录了多少个数据 blob

​

SharedMergeTreeBlobsListInlineFilesWritten

有多少小文件以内联方式存储在 SharedMergeTree 的 blobs.list Map 中，而非作为独立 blob 存储

​

SharedMergeTreeBlobsListPartsWritten

已写入的 SharedMergeTree blob-list parts 数量 (每个对应一个合并后的 blobs.list 节点)

​

SharedMergeTreeCondemnedPartsKillRequest

用于移除废弃 parts 的 ZooKeeper 请求数

​

SharedMergeTreeCondemnedPartsLockConflict

因冲突而未能获取锁的次数

​

SharedMergeTreeCondemnedPartsRemoved

已移除的废弃 parts 数量

​

SharedMergeTreeDataPartsFetchAttempt

尝试拉取数据分区片段的次数

​

SharedMergeTreeDataPartsFetchFromPeer

从 peer 拉取数据分区片段的次数

​

SharedMergeTreeDataPartsFetchFromPeerMicroseconds

从 peer 拉取数据分区片段耗时 (微秒)

​

SharedMergeTreeDataPartsFetchFromS3

从 S3 拉取数据分区片段的次数

​

SharedMergeTreeFetchDeduplicated

因该分片已被其他线程拉取或生成而被去重的分片拉取次数

​

SharedMergeTreeHandleBlockingParts

scheduleDataProcessingJob 中要处理的阻塞 parts 数量

​

SharedMergeTreeHandleBlockingPartsMicroseconds

在 scheduleDataProcessingJob 中处理阻塞的 parts 所花费的时间

​

SharedMergeTreeHandleFetchPartsMicroseconds

在 scheduleDataProcessingJob 中处理已拉取 parts 所花费的时间

​

SharedMergeTreeHandleOutdatedParts

在 scheduleDataProcessingJob 中处理的过期分区片段数量

​

SharedMergeTreeHandleOutdatedPartsMicroseconds

在 scheduleDataProcessingJob 中处理过期分区片段所用的时间

​

SharedMergeTreeLoadChecksumAndIndexesMicroseconds

仅 SharedMergeTree 的 loadColumnsChecksumsIndexes 耗时

​

SharedMergeTreeMergeMutationAssignmentAttempt

尝试分配合并或变更任务的次数

​

SharedMergeTreeMergeMutationAssignmentFailedWithConflict

因 Keeper 中发生冲突而导致分配 merge 或变更失败的次数

​

SharedMergeTreeMergeMutationAssignmentFailedWithNothingToDo

尝试分配合并或变更任务但因没有可合并内容而失败的次数

​

SharedMergeTreeMergeMutationAssignmentSuccessful

尝试分配合并或变更任务的次数

​

SharedMergeTreeMergePartsMovedToCondemned

移至废弃目录的 parts 数量

​

SharedMergeTreeMergePartsMovedToOudated

被移动到过期目录的 parts 数量

​

SharedMergeTreeMergeSelectingTaskMicroseconds

SMT 的合并选择任务耗时 (微秒)

​

SharedMergeTreeMetadataCacheHintLoadedFromCache

未访问 Keeper 即命中元数据缓存提示的次数

​

SharedMergeTreeOptimizeAsync

已执行的异步 OPTIMIZE 查询

​

SharedMergeTreeOptimizeSync

已执行同步 OPTIMIZE 查询

​

SharedMergeTreeOutdatedPartsConfirmationInvocations

确认过期分区片段的调用次数

​

SharedMergeTreeOutdatedPartsConfirmationRequest

用于配置过期分区片段时使用的 ZooKeeper 请求数

​

SharedMergeTreeOutdatedPartsHTTPRequest

为确认过期分区片段而发送的 HTTP 请求数量

​

SharedMergeTreeOutdatedPartsHTTPResponse

为确认过期分区片段而发送的 HTTP 响应数量

​

SharedMergeTreePartitionOperationRetries

因并发变更而不得不重试 Keeper 多重写入的分区级操作 (DROP/MOVE/REPLACE/CLONE/TRUNCATE PARTITION) 次数

​

SharedMergeTreePartsKillerMicroseconds

parts killer 主线程耗费的时间

​

SharedMergeTreePartsKillerParts

killer 已调度的 parts 数量

​

SharedMergeTreePartsKillerPartsMicroseconds

移除 parts 需要多长时间 (由多个线程执行)

​

SharedMergeTreePartsKillerRuns

parts killer 的运行次数

​

SharedMergeTreeReplicaSetUpdatesFromZooKeeper

从 ZooKeeper 更新副本集的次数

​

SharedMergeTreeReplicaSetUpdatesFromZooKeeperMicroseconds

更新副本集所花费的时间

​

SharedMergeTreeReplicaSetUpdatesFromZooKeeperRequests

为更新副本集而发起的 ZooKeeper 请求总数

​

SharedMergeTreeReplicaSetUpdateTaskRuns

updateReplicaSetTask 运行的次数

​

SharedMergeTreeScheduleDataProcessingJob

scheduleDataProcessingJob 被调用的次数/

​

SharedMergeTreeScheduleDataProcessingJobMicroseconds

scheduleDataProcessingJob 的执行时间

​

SharedMergeTreeScheduleDataProcessingJobNothingToScheduled

scheduleDataProcessingJob 被调用但没有可执行操作的次数

​

SharedMergeTreeSelectPartsForCoordinatedFetchMicroseconds

selectPartsForCoordinatedFetch 耗时

​

SharedMergeTreeSelectPartsForCoordinatedFetchParts

被 selectPartsForCoordinatedFetch 选中的 parts 数量

​

SharedMergeTreeSelectPartsForFullFetchMicroseconds

selectPartsForFullFetch 的耗时

​

SharedMergeTreeSelectPartsForFullFetchParts

被 selectPartsForFullFetch 选中的 parts 数量

​

SharedMergeTreeSelectPartsForRendezvousFetchMicroseconds

selectPartsForRendezvousFetch 的耗时

​

SharedMergeTreeSelectPartsForRendezvousFetchParts

selectPartsForRendezvousFetch 选中的 parts 数量

​

SharedMergeTreeSnapshotDeadLocksReclaimed

已回收的 Keeper 节点或子树数量，这些节点或子树属于不再存活的 lightweight snapshots

​

SharedMergeTreeSnapshotPartsCleanerMicroseconds

SnapshotCleanerThread 已运行多长时间

​

SharedMergeTreeSnapshotPartsCleanerParts

SnapshotCleanerThread 尝试清理一个 part 所需的时间

​

SharedMergeTreeSnapshotPartsCleanerPartsMicroseconds

SnapshotCleanerThread 清理 parts 所需的时间

​

SharedMergeTreeSnapshotPartsCleanerRuns

SnapshotCleanerThread 的运行次数

​

SharedMergeTreeSnapshotPartsCleanRequest

SnapshotCleanerThread 决定清理某个 part 的次数

​

SharedMergeTreeSnapshotPartsRemoved

SnapshotCleanerThread 成功清理 part 的次数

​

SharedMergeTreeTryUpdateDiskMetadataCacheForPartMicroseconds

在 scheduleDataProcessingJob 中 tryUpdateDiskMetadataCacheForPart 的耗时

​

SharedMergeTreeVirtualPartsUpdateMicroseconds

虚拟分区片段更新 (微秒)

​

SharedMergeTreeVirtualPartsUpdates

虚拟分区片段更新次数

​

SharedMergeTreeVirtualPartsUpdatesByLeader

按 leader 统计的虚拟分区片段更新

​

SharedMergeTreeVirtualPartsUpdatesForMergesOrStatus

由非默认后台作业触发的虚拟分区片段更新

​

SharedMergeTreeVirtualPartsUpdatesFromPeer

来自对等节点的虚拟分区片段更新次数

​

SharedMergeTreeVirtualPartsUpdatesFromPeerMicroseconds

来自对等节点的虚拟分区片段更新时间 (微秒)

​

SharedMergeTreeVirtualPartsUpdatesFromZooKeeper

来自 ZooKeeper 的虚拟分区片段更新次数

​

SharedMergeTreeVirtualPartsUpdatesFromZooKeeperFullyCached

虚拟分区片段发现操作中，所有分区均来自发现缓存、未从 ZooKeeper 拉取任何数据的次数

​

SharedMergeTreeVirtualPartsUpdatesFromZooKeeperMicroseconds

来自 ZooKeeper 的虚拟分区片段更新耗时 (微秒)

​

SharedMergeTreeVirtualPartsUpdatesFromZooKeeperPartitions

在虚拟分区片段发现过程中，因其 stat 在发现缓存中缺失或已过期而从 ZooKeeper 发现的分区数量

​

SharedMergeTreeVirtualPartsUpdatesFromZooKeeperPartitionsFromCache

在虚拟分区片段发现过程中，因其 stat 在发现缓存中已是最新而被跳过的分区数量

​

SharedMergeTreeVirtualPartsUpdatesLeaderFailedElection

虚拟分区片段更新 leader 选举失败

​

SharedMergeTreeVirtualPartsUpdatesLeaderSuccessfulElection

虚拟分区片段更新 leader 成功选出

​

SharedMergeTreeVirtualPartsUpdatesPeerNotFound

来自对等节点的虚拟更新失败，因为未找到任何对等节点

​

SharedPartsLockHoldMicroseconds

在 MergeTree 表中持有共享数据分区片段锁的总耗时

​

SharedPartsLocks

MergeTree 表中共享数据分区片段锁的获取次数

​

SharedPartsLockWaitMicroseconds

等待 MergeTree 表中共享数据分区片段锁的总耗时

​

SleepFunctionCalls

调用 sleep 函数 (sleep、sleepEachRow) 的次数。

​

SleepFunctionElapsedMicroseconds

在 sleep 函数 (sleep、sleepEachRow) 中休眠耗费的时间。

​

SleepFunctionMicroseconds

在 sleep 函数 (sleep、sleepEachRow) 中设置的睡眠时长。

​

SlowRead

从文件读取时发生慢读的次数。这表明系统负载过高。阈值由 read_backoff_* 设置控制。

​

软缺页

查询执行线程中的软缺页次数。软缺页通常表示内存分配器缓存未命中，因此需要操作系统创建新的内存映射，并随后分配一个物理内存页。

​

StatelessWorkerCreateLeaseErrors

向无状态工作线程发现服务发起的 create_lease 请求失败的次数 (任何错误或超时均计入) 。

​

StatelessWorkerCreateLeaseMicroseconds

向 无状态工作线程发现服务发起 create_lease 请求所耗费的总时间。

​

StatelessWorkerCreateLeaseRequests

为获取工作线程而向 无状态工作线程发现服务发送的 create_lease 请求数。

​

StatelessWorkerDiscoveryCreateLeaseErrors

无状态工作线程 discovery 服务返回错误的 create_lease 请求数。

​

StatelessWorkerDiscoveryCreateLeaseMicroseconds

无状态工作线程发现服务处理 create_lease 请求所耗费的总时间。

​

StatelessWorkerDiscoveryCreateLeaseRequests

无状态工作线程发现服务处理的 create_lease 请求数。

​

StatelessWorkerDiscoveryCreateWorkerErrors

无状态工作线程发现服务返回错误的 create_worker 请求数。

​

StatelessWorkerDiscoveryCreateWorkerMicroseconds

无状态工作线程发现服务处理 create_worker 请求所耗费的总时间。

​

StatelessWorkerDiscoveryCreateWorkerRequests

无状态工作线程发现服务处理的 create_worker 请求数。

​

StatelessWorkerDiscoveryDeleteWorkerErrors

无状态工作线程发现服务返回错误的 delete_worker 请求数。

​

StatelessWorkerDiscoveryDeleteWorkerMicroseconds

无状态工作线程发现服务处理 delete_worker 请求所耗费的总时间。

​

StatelessWorkerDiscoveryDeleteWorkerRequests

无状态工作线程发现服务处理的 delete_worker 请求数。

​

StatelessWorkerDiscoveryGetLeaseErrors

无状态工作线程发现服务返回错误的 get_lease 请求数。

​

StatelessWorkerDiscoveryGetLeaseMicroseconds

无状态工作线程发现服务处理 get_lease 请求所耗费的总时间。

​

StatelessWorkerDiscoveryGetLeaseRequests

无状态工作线程发现服务处理的 get_lease 请求数。

​

StatelessWorkerDiscoveryGetWorkerErrors

无状态工作线程发现服务返回错误的 get_worker 请求数。

​

StatelessWorkerDiscoveryGetWorkerMicroseconds

无状态工作线程发现服务处理 get_worker 请求所花费的总时间。

​

StatelessWorkerDiscoveryGetWorkerRequests

由 无状态工作线程发现服务处理的 get_worker 请求数。

​

StatelessWorkerDiscoveryHeartbeatErrors

无状态工作线程发现服务返回错误的心跳请求数。

​

StatelessWorkerDiscoveryHeartbeatMicroseconds

无状态工作线程发现服务处理 heartbeat 请求所耗费的总时间。

​

StatelessWorkerDiscoveryHeartbeatRequests

无状态工作线程发现服务处理的 heartbeat 请求数。

​

StatelessWorkerDiscoveryHeartbeatsRejected

无状态工作线程发现服务因工作线程已被驱逐而拒绝的心跳次数。

​

StatelessWorkerDiscoveryInternalErrors

无状态工作线程发现服务因内部错误 (异常或协调存储故障) 而未能处理的请求数，不包括因请求无效而被拒绝的请求。

​

StatelessWorkerDiscoveryKeeperTransactionRetries

因协调存储 (Keeper) 状态被并发修改，无状态工作线程发现 (stateless worker discovery) 服务重试的写入事务数。

​

StatelessWorkerDiscoveryListWorkersErrors

无状态工作线程发现服务返回错误的 list_workers 请求数。

​

StatelessWorkerDiscoveryListWorkersMicroseconds

无状态工作线程发现服务处理 list_workers 请求所耗费的总时间。

​

StatelessWorkerDiscoveryListWorkersRequests

无状态工作线程发现服务处理的 list_workers 请求数。

​

StatelessWorkerDiscoveryTenantErrors

无状态工作线程发现服务返回错误的tenant管理请求数。

​

StatelessWorkerDiscoveryTenantMicroseconds

无状态工作线程发现服务处理 tenant 管理请求所耗费的总时间。

​

StatelessWorkerDiscoveryTenantRequests

由 无状态工作线程发现服务处理的 tenant 管理请求 (创建、更新、删除、获取或列出 tenant) 数量。

​

StatelessWorkerDiscoveryUpdateLeaseErrors

无状态工作线程发现服务返回错误的 update_lease 请求数。

​

StatelessWorkerDiscoveryUpdateLeaseMicroseconds

无状态工作线程发现服务处理 update_lease 请求所耗费的总时间。

​

StatelessWorkerDiscoveryUpdateLeaseRequests

无状态工作线程发现服务处理的 update_lease 请求数。

​

StatelessWorkerDiscoveryWorkersHeartbeatExpired

因停止发送 heartbeat 而被 无状态工作线程发现服务回收的 stateless worker 数量。

​

StatelessWorkerDiscoveryWorkersLeased

无状态工作线程发现服务新租借给租户的无状态工作线程数量。

​

StatelessWorkerDiscoveryWorkersLeaseExpired

因租约过期而被 stateless worker discovery 服务回收的 无状态工作线程数量。

​

StatelessWorkerDiscoveryWorkersUnavailable

租户请求但 stateless worker discovery 服务无法提供的无状态工作线程数量，原因是没有空闲的工作线程，或已达到该租户的工作线程上限。

​

StatelessWorkerGetLeaseErrors

向 无状态工作线程发现服务发起的 get_lease 请求失败的次数 (任何错误或超时) 。

​

StatelessWorkerGetLeaseMicroseconds

向无状态工作线程发现服务发起 get_lease 请求所耗费的总时间。

​

StatelessWorkerGetLeaseRequests

发送到 无状态工作线程discovery 服务的 get_lease 请求数，用于刷新已租用工作线程列表。

​

StatelessWorkerNotAccessible

已租用的 无状态工作线程被检测为尚不可达，在通过可访问性检查之前被排除出查询分配的次数。

​

StatelessWorkerProvided

为分布式查询执行而提供给查询使用的无状态工作线程数量。

​

StatelessWorkerProvisioningMicroseconds

查询等待 无状态工作线程 完成预配所花费的总时间。

​

StatelessWorkerProvisioningWaits

查询需要等待 无状态工作线程 discovery 服务提供工作线程的次数。

​

StatelessWorkerRequested

查询为进行分布式查询执行而请求的无状态工作线程数量。

​

StatelessWorkerServerHeartbeatErrors

无状态工作线程向无状态工作线程发现服务发送 心跳 失败的次数 (包括任何 error 或 timeout) 。

​

StatelessWorkerServerHeartbeatMicroseconds

无状态工作线程向无状态工作线程发现服务发送心跳所耗费的总时间。

​

StatelessWorkerServerHeartbeatRequests

无状态工作线程向无状态工作线程发现服务发送的心跳次数。

​

StatelessWorkerServerLeasesLost

无状态工作线程的租约结束并进入等待关闭状态的次数。

​

StatelessWorkerServerRegisterErrors

无状态工作线程向无状态工作线程发现服务注册失败的请求数 (包括任何错误或超时) 。

​

StatelessWorkerServerRegisterMicroseconds

无状态工作线程 向 无状态工作线程 discovery 服务进行注册所耗费的总时间。

​

StatelessWorkerServerRegisterRequests

无状态工作线程 向 无状态工作线程 discovery 服务发送的注册请求数。

​

StatelessWorkerServerTenantBindings

无状态工作线程被分配给某个租户以处理其查询的次数。

​

StatelessWorkerTimeToAvailableMicroseconds

从租用的 无状态工作线程 首次出现在 discovery 服务中，到其通过可访问性 check 并可供查询执行使用之间的总时间 (按各工作线程累加) 。

​

StatelessWorkerUpdateLeaseErrors

向无状态工作线程发现服务发送的 update_lease 请求失败的次数 (任何错误或超时) 。

​

StatelessWorkerUpdateLeaseMicroseconds

向无状态工作线程发现服务发送 update_lease 请求所耗费的总时间。

​

StatelessWorkerUpdateLeaseRequests

发送到 无状态工作线程 discovery 服务以续约 worker lease 的 update_lease 请求数。

​

StorageBufferErrorOnFlush

Buffer 表中的缓冲区因写入目标表时出错而无法刷新的次数。

​

StorageBufferFlush

Buffer 表中缓冲区刷写到存储的次数。

​

StorageBufferLayerLockReadersWaitMilliseconds

读取时等待 Buffer 层的时间。

​

StorageBufferLayerLockWritersWaitMilliseconds

等待空闲 Buffer 层 以执行写入的时间 (可用于调优 Buffer 层) 。

​

StorageBufferPassedAllMinThresholds

在 ‘Buffer’ 表中，达到所有最小阈值条件并触发缓冲区刷新的次数。

​

StorageBufferPassedBytesFlushThreshold

在 ‘Buffer’ 表中，为刷新缓冲区而达到仅后台按字节数计算的刷写阈值的次数。这是仅限专家使用的指标。如果你读到这里，但并非专家，请停止阅读。

​

StorageBufferPassedBytesMaxThreshold

在 ‘Buffer’ 表中，为刷新缓冲区而达到最大字节阈值的次数。

​

StorageBufferPassedRowsFlushThreshold

在 ‘Buffer’ 表中，为刷写缓冲区而达到仅在后台生效的行数 刷写阈值 的次数。这是一个仅供专家使用的指标。如果你看到这里但并非专家，请停止阅读。

​

StorageBufferPassedRowsMaxThreshold

在 ‘Buffer’ 表中，因达到最大行数阈值而触发缓冲区刷写的次数。

​

StorageBufferPassedTimeFlushThreshold

在“Buffer”表中，仅在后台执行且基于时间的 刷写阈值 达到时触发缓冲区 flush 的次数。这是仅供专家使用的指标。如果你看到这段说明但并非专家，请停止阅读。

​

StorageBufferPassedTimeMaxThreshold

在 ‘Buffer’ 表中，因达到最大时间阈值而触发缓冲区刷写的次数。

​

StorageConnectionsCreated

已创建的存储连接数

​

StorageConnectionsElapsedMicroseconds

创建存储连接的总耗时

​

StorageConnectionsErrors

为存储创建连接失败的次数

​

StorageConnectionsExpired

存储后端的过期连接数

​

StorageConnectionsPreserved

为存储保留的连接数

​

StorageConnectionsReset

存储连接被重置的次数

​

StorageConnectionsReused

各存储后端的复用连接数

​

StreamingExchangeConnectionWaitMicroseconds

流式 exchange sink 等待接收端 task 建立 connection 所花费的时间。

​

StreamingExchangeDeserializeMicroseconds

将流式 exchange 数据包解压并反序列化为块所花费的时间。

​

StreamingExchangeEarlyCloses

流式 exchange 数据源在 stream 尚未读完之前通知其发送端停止的次数，例如因为已满足 LIMIT。对于已经退出的发送端，不计入该次数。

​

StreamingExchangePacketsReceived

从流式 exchange 读取的数据包数：每个块对应一个数据包，此外每个 stream 还有一个流结束数据包。

​

StreamingExchangePacketsSent

完整写入流式 exchange 套接字的数据包数量：每个块对应一个数据包，此外每个 stream 还有一个流结束数据包。数据包只有被完整写入时才计数；因接收方不再需要更多数据而被截断的数据包不计入。

​

StreamingExchangeReceiveBytes

从分布式查询计划中流式 exchange 的套接字读取的字节数。NetworkReceiveBytes 不统计这部分字节。

​

StreamingExchangeReceiveWaitMicroseconds

流式 exchange 源等待发送方发来下一批字节所耗费的时间。

​

StreamingExchangeSendBytes

写入分布式查询计划中流式 exchange 套接字的字节数。NetworkSendBytes 不会统计这部分字节。

​

StreamingExchangeSendQueueFullMicroseconds

流式 exchange sink 因等待套接字的数据包队列已满而未能获取块所持续的时间。

​

StreamingExchangeSerializedBytes

流式 exchange packet 中 Native 块压缩前的字节数，每个 packet 在序列化时计数一次。与 StreamingExchangeSendBytes 对比即可得出 shuffle 或 gather 的压缩率；而广播会把每个 packet 发送到所有目标端，因此此时 StreamingExchangeSendBytes 会随目标端数量增长。

​

StreamingExchangeSerializeMicroseconds

将块序列化并压缩为流式 exchange 数据包所花费的时间。

​

对已排序列求和耗时 (毫秒)

对已排序列求和所花费的总时间

​

SuspendSendingQueryToShard

启用 async_query_sending_for_remote 时，向分片发送查询被暂停的总次数。

​

SynchronousReadWaitMicroseconds

异步本地读取中等待同步读取所耗费的时间。

​

SynchronousRemoteReadWaitMicroseconds

等待同步远程读取的耗时。

​

SystemLogErrorOnFlush

任一系统日志未能刷新到对应系统表的次数。系统会重复尝试刷新。

​

SystemTimeMicroseconds

用于处理查询及其他任务的线程在操作系统内核模式下执行 CPU 指令所耗费的总时间。即花费在系统调用上的时间，不包括阻塞式系统调用期间的等待时间。

​

TableFunctionExecute

表函数调用次数。

​

TextIndexDiscardHint

添加了从文本索引直接读取提示、但因选择性低而被丢弃的索引粒度数量。

​

TextIndexDiscardPatternScan

文本索引中，基于模式的字典扫描因待读取的倒排列表数量超过阈值而被放弃的次数。

​

TextIndexGenericExclusionSearchAlgorithm

在 文本索引 上使用 generic exclusion search algorithm 的次数。

​

TextIndexGenericExclusionSearchStepLimitReached

在 文本索引 上执行 generic exclusion search 时达到 merge_tree_generic_exclusion_search_max_steps 上限，从而直接接受剩余 mark ranges、不再继续 split 的次数。

​

TextIndexHeaderCacheHits

请求头在缓存中的命中次数。

​

TextIndexHeaderCacheMisses

请求头在缓存中未命中的次数。

​

TextIndexLazyAdvanceCount

惰性倒排列表模式下执行的推进操作次数。

​

TextIndexLazyBlocksSkippedResolved

在惰性倒排列表模式下，由于输出区域已确定 (对于 OR 为全 1，对于 AND 为全 0) 而被跳过的 打包块 数量。

​

TextIndexLazyBruteForceIntersections

在惰性倒排列表模式下执行的穷举求交次数。

​

TextIndexLazyLeapfrogIntersections

在惰性倒排列表模式下进行的 leapfrog 求交次数。

​

TextIndexLazyPackedBlocksDecoded

惰性倒排列表模式下已解码的打包块数量。

​

TextIndexLazySegmentsBuilt

在惰性倒排列表模式下，实际被读取并解码的分段数量 (缓存未命中) 。

​

TextIndexLazySegmentsPrepared

在惰性倒排列表模式下，已准备的分段数量 (从磁盘读取或已缓存) 。

​

TextIndexLazySegmentsSkippedDense

在惰性倒排列表模式下，未解码块、而是按整体进行填充 (OR 使用 memset，AND 使用 increment) 的完全稠密分段数量。

​

TextIndexLazySegmentsSkippedResolved

在惰性倒排列表模式下，由于输出区域已确定 (OR 为全 1，AND 为全 0) 而跳过的分段数量。

​

TextIndexPhraseCandidates

candidate 驱动的 phrase search 所检查的候选行 (postings 交集) 。

​

TextIndexPhraseFallbacks

phrase 查询跳过 文本索引 的次数：由于预估该 phrase 匹配的行数超过 ‘text_index_hint_max_selectivity’，因而改为直接在列上求值。

​

TextIndexPhraseMatchMicroseconds

在候选行上匹配短语位置所耗费的总时间。

​

TextIndexPhraseSearches

在 文本索引 上执行的 phrase search 次数。对同一 part 中同一 phrase 的重复搜索直接由 cache 返回结果，不计入此项。

​

TextIndexPositionsBlocksRead

为在 文本索引 上匹配 phrase 查询而读取的位置块数量。横跨两个 candidate window 的块每次读取只计一次。

​

TextIndexPositionsBlocksTotal

在选择要读取哪些块之前，phrase 标记的位置块总数。

​

TextIndexPositionsBytesRead

为在 文本索引 上匹配 phrase 查询而读取的位置块字节数。

​

TextIndexPositionsDecodeMicroseconds

用于短语搜索的文本索引位置列表 (.pos) 解码所耗费的总时间。

​

TextIndexPostingsCacheHits

文本索引倒排列表在缓存中命中的次数。

​

TextIndexPostingsCacheMisses

文本索引倒排列表在缓存中未命中的次数。

​

TextIndexReadDictionaryBlocks

从磁盘读取文本索引字典块的次数。

​

TextIndexReaderTotalMicroseconds

读取文本索引花费的总时间。

​

TextIndexReadGranulesMicroseconds

读取并分析文本索引粒度的总耗时。

​

TextIndexReadPostings

从文本索引读取倒排列表的次数。

​

TextIndexReadSparseIndexBlocks

从文本索引读取稀疏索引块的次数。

​

TextIndexTemporarySegmentsWritten

构建 文本索引es 期间写入的临时分段数。

​

TextIndexTokensCacheHits

文本索引标记信息在缓存中命中的次数。

​

TextIndexTokensCacheMisses

文本索引标记信息在缓存中未命中的次数。

​

TextIndexTokensCacheNegativeHits

在缓存中命中某个不存在的 文本索引 标记的次数。

​

TextIndexTokensCacheNegativeMisses

在字典 lookup 之后被加入缓存的不存在的 文本索引 tokens 数量。

​

TextIndexUsedEmbeddedPostings

字典中嵌入的倒排列表被使用的次数。

​

TextIndexUseHint

已添加“直接从文本索引读取”提示且实际使用了该提示的索引粒度数量。

​

ThreadPoolReaderPageCacheHit

ThreadPoolReader 内部读取命中页缓存的次数。

​

ThreadPoolReaderPageCacheHitBytes

ThreadPoolReader 命中页缓存时读取的字节数。

​

ThreadPoolReaderPageCacheHitElapsedMicroseconds

ThreadPoolReader 从 页缓存 读取数据所耗费的时间。

​

ThreadPoolReaderPageCacheMiss

ThreadPoolReader 内部未从 页缓存 读取、而是转交给线程池处理的次数。

​

ThreadPoolReaderPageCacheMissBytes

在 ThreadPoolReader 中，未从页缓存读取而是移交给线程池处理时读取的字节数。

​

ThreadPoolReaderPageCacheMissElapsedMicroseconds

在 ThreadPoolReader 的异步作业中读取数据所耗费的时间——当读取不是来自页缓存时。

​

ThreadpoolReaderPrepareMicroseconds

准备所耗费的时间 (例如调用 reader 的寻道 seek() method)

​

ThreadpoolReaderReadBytes

异步读取过程中从线程池任务中读取的字节数

​

ThreadpoolReaderSubmit

异步读取期间从线程池任务中读取的字节数

​

ThreadpoolReaderSubmitLookupInCacheMicroseconds

检查内容是否已缓存所花费的时间

​

ThreadpoolReaderSubmitReadSynchronously

未在线程池中调度任务而改为同步读取的次数

​

ThreadpoolReaderSubmitReadSynchronouslyBytes

同步读取的字节数

​

ThreadpoolReaderSubmitReadSynchronouslyMicroseconds

同步读取所花费的时间

​

线程池读取任务微秒数

异步读取期间获取数据所花费的时间

​

ThrottlerSleepMicroseconds

查询为满足所有限流设置而休眠的总时间。

​

TinyS3Clients

复用另一客户端现有身份验证提供商的 S3 客户端副本数。

​

UncompressedCacheHits

在未压缩缓存中命中数据块的次数 (从而避免了解压) 。

​

未压缩缓存未命中次数

数据块在未压缩缓存中未命中的次数 (因此需要进行解压缩) 。

​

UncompressedCacheWeightLost

从未压缩缓存中淘汰的字节数。

​

UniqueKeyBitmapLoadMicroseconds

DeleteBitmapCache 未命中时，读取并反序列化 UNIQUE KEY delete-bitmap 辅助文件所耗费的时间。

​

UniqueKeyBitmapUpdates

已写入的 UNIQUE KEY delete-bitmap 辅助文件数量 (每次替换 / DELETE 提交各写入一个) 。

​

UniqueKeyIndexCacheHits

在 UNIQUE KEY 索引缓存中命中条目的次数，因此无需加载 SST 块。

​

UniqueKeyIndexCacheLookupMicroseconds

UniqueKeyIndexCache::Lookup + UniqueKeyIndexCache::Insert 中的挂钟时间 (ClickHouse 侧用于 RocksDB 块缓存的 CacheBase 适配器) 。

​

UniqueKeyIndexCacheMisses

在 UNIQUE KEY 索引缓存中未命中条目、因此需要从磁盘加载 SST 块的次数。

​

UniqueKeyLoadTimeSSTRebuildCount

在“刷写前崩溃”窗口之后，于加载时重建了 unique_key_index.sst 的 UNIQUE KEY parts 数量。

​

UniqueKeyLoadTimeSSTRebuildMicroseconds

在加载时重建 unique_key_index.sst 所耗费的总时间 (顺序读取 UK 列 + 写入 SST) 。

​

UniqueKeySSTWriteMicroseconds

SSTIndexWriter 整个生命周期内耗费的总挂钟时间——包括 SST Open、每次 addEncoded Put，以及 finish 中的 Finish 和 WriteBuffer finalize (+ fsync) (SST 字节直接流式写入 part 存储的 WriteBuffer) 。不包括在构造 writer 之前由静态辅助函数完成的工作 (编码 + 非前缀路径排序) 。每个 writer 仅上报一次。

​

USearchAddComputedDistances

向 usearch 索引添加向量时计算距离的次数。

​

USearchAddCount

添加到 usearch 索引中的向量数。

​

USearchAddVisitedMembers

向 usearch 索引添加向量时访问的节点数。

​

USearchSearchComputedDistances

搜索 USearch 索引时计算距离的次数。

​

USearchSearchCount

在 usearch 索引中执行的搜索操作次数。

​

USearchSearchVisitedMembers

搜索 usearch 索引时访问的节点数。

​

UserThrottlerBytes

通过 max_network_bandwidth_for_user 限流器传输的字节数。

​

UserThrottlerSleepMicroseconds

查询因遵循 max_network_bandwidth_for_user 限流而休眠的总时长。

​

用户态时间 (微秒)

处理 (查询及其他任务) 过程中，线程在用户态执行 CPU 指令所花费的总时间。这也包括因访问主内存、缓存未命中、分支预测错误、超线程等导致 CPU 管道停顿的时间。

​

VectorSimilarityIndexCacheHits

索引粒度在向量索引缓存中被命中的次数。

​

VectorSimilarityIndexCacheMisses

索引粒度在向量索引缓存中未命中、因而必须从磁盘读取的次数。

​

VectorSimilarityIndexCacheWeightLost

从向量索引缓存中淘汰的字节数估计值。

​

VersionedCollapsingSortedMilliseconds

对已排序列进行版本折叠所花费的总时间

​

WaitMarksLoadMicroseconds

加载标记所花费的时间

​

WaitPrefetchTaskMicroseconds

等待预取读取器的耗时

​

WasmDeserializationMicroseconds

执行 WebAssembly 代码耗费的时间

​

WasmGuestExecuteMicroseconds

执行 WebAssembly 代码耗费的时间

​

WasmMemoryAllocated

为 WebAssembly 隔离区分配的内存总量

​

WasmModuleInstatiate

创建的 WebAssembly 隔离区数

​

WasmSerializationMicroseconds

执行 WebAssembly 代码耗费的时间

​

WasmTotalExecuteMicroseconds

执行 WebAssembly 代码耗费的时间

​

WriteBufferFromFileDescriptorWrite

向文件描述符执行写入 (write/pwrite) 的次数。不包括套接字。

​

WriteBufferFromFileDescriptorWriteBytes

写入文件描述符的字节数。如果文件已压缩，这里显示的是压缩后数据的大小。

​

WriteBufferFromFileDescriptorWriteFailed

对文件描述符执行写入 (write/pwrite) 操作失败的次数。

​

WriteBufferFromHTTPBytes

WriteBufferFromHTTP 接收和发送的载荷总字节数。不包括 HTTP 请求头。

​

WriteBufferFromHTTPRequestsSent

WriteBufferFromHTTP 发送的 HTTP 请求数

​

WriteBufferFromS3Bytes

写入 S3 的字节数。

​

WriteBufferFromS3Microseconds

向 S3 写入所花费的时间。

​

WriteBufferFromS3RequestsErrors

写入 S3 时发生的异常数。

​

WriteBufferFromS3WaitInflightLimitMicroseconds

当当前请求数达到 s3_max_inflight_parts_for_one_file 定义的上限时，等待其中部分请求完成所花费的时间。

​

ZooKeeperBytesReceived

与 ZooKeeper 通信时通过网络接收的字节总数。

​

ZooKeeperBytesSent

与 ZooKeeper 通信期间通过网络发送的字节数。

​

ZooKeeperCheck

发送到 ZooKeeper 的“check”请求数。通常它们只有作为复杂事务的一部分时才有意义，单独看时意义不大。

​

ZooKeeperClose

主动关闭与 ZooKeeper 的连接的次数。

​

ZooKeeperCreate

发送到 ZooKeeper 的 create 请求数。

​

ZooKeeperExists

发往 ZooKeeper 的 exists 请求数。

​

ZooKeeperGet

发送到 ZooKeeper 的“get”请求数。

​

ZooKeeperGetACL

ZooKeeper 的 ‘getACL’ 请求数。

​

ZooKeeperHardwareExceptions

与网络相关 (连接丢失或类似情况) 的 ZooKeeper 操作中发生的异常数量。

​

ZooKeeperInit

与 ZooKeeper 成功建立连接的次数。

​

ZooKeeperList

向 ZooKeeper 发出的“list” (getChildren) 请求数。

​

ZooKeeperListRecursive

向 ZooKeeper 发送的 listRecursive 请求数。

​

ZooKeeperMulti

发送到 ZooKeeper 的 ‘multi’ 请求数 (复合事务) 。

​

ZooKeeperMultiRead

ZooKeeper 读取型“multi”请求 (复合事务) 的数量。

​

ZooKeeperMultiWrite

向 ZooKeeper 发起的写入 multi 请求数 (复合事务) 。

​

ZooKeeperOtherExceptions

与 ZooKeeper 交互时发生的异常数量，不包括 ZooKeeperUserExceptions 和 ZooKeeperHardwareExceptions。

​

ZooKeeperReconfig

发送到 ZooKeeper 的“reconfig”请求数量。

​

ZooKeeperRemove

向 ZooKeeper 发出的“remove”请求数。

​

ZooKeeperSet

发往 ZooKeeper 的“set”请求数。

​

ZooKeeperSync

向 ZooKeeper 发出的 sync 请求数。这类请求通常既不常用，也很少有必要。

​

ZooKeeperTransactions

ZooKeeper 操作次数，包括读操作、写操作以及多重事务。

​

ZooKeeperUserExceptions

与数据相关的 ZooKeeper 操作过程中发生的异常数量 (如节点不存在、版本错误等) 。

​

ZooKeeperWaitMicroseconds

创建请求后等待 ZooKeeper 响应所耗费的总微秒数，对所有发出请求的线程求和。

​

ZooKeeper watch 回调耗时 (微秒)

在 ZooKeeper watch 回调中 (网络线程) 花费的总耗时。

​

ZooKeeperWatchCallbackErrors

ZooKeeper watch 回调中抛出的异常数量。

​

ZooKeeperWatchResponse

从 ZooKeeper 收到 watch 通知的次数。

​

ZooKeeperWatchTriggeredBackupCoordination

分派到备份/恢复协调的 watch 通知数量。

​

ZooKeeperWatchTriggeredClusterDiscovery

分派到 ClusterDiscovery 的 watch 通知数量。

​

ZooKeeperWatchTriggeredDistributedDDL

分发到 DDLWorker 队列的 watch 通知数量。

​

ZooKeeperWatchTriggeredMaterializedViewRefresh

派发给 MaterializedView 刷新协调模块的 watch 通知数量。

​

ZooKeeperWatchTriggeredObjectStorageQueue

分派到 ObjectStorageQueue / S3Queue 的 watch 通知数量。

​

ZooKeeperWatchTriggeredOther

分派给未分类回调的 watch 通知数量。

​

ZooKeeperWatchTriggeredReplicatedAccessControl

分派给 ReplicatedAccessStorage 的 watch 通知数量。

​

ZooKeeperWatchTriggeredReplicatedMergeTreeLeaderElection

分发给 ReplicatedMergeTree leader 选举 / 副本锁的 watch 通知数量。

​

ZooKeeperWatchTriggeredReplicatedMergeTreeLog

分发给 ReplicatedMergeTree 日志条目的 watch 通知数量。

​

ZooKeeperWatchTriggeredReplicatedMergeTreeMutations

派发到 ReplicatedMergeTree 变更操作的 watch 通知数量。

​

ZooKeeperWatchTriggeredReplicatedMergeTreeReplicaSync

等待副本处理日志记录 (SYNC REPLICA、ALTER、变更) 期间分发的 watch 通知数量。

​

ZooKeeperWatchTriggeredUserDefinedSQLObjects

分发到 UserDefinedSQLObjectsZooKeeperStorage 的 watch 通知数。

​

ZooKeeperWatchTriggeredWorkloadEntity

已分发到 WorkloadEntityKeeperStorage 的 watch 通知数量。

​

KeeperLogsEntryReadFromCommitCache

已废弃的事件，用于统计从 Keeper 提交日志缓存中读取的日志条目数量。

​

KeeperLogsPrefetchedEntries

已废弃的事件，用于统计 Keeper 中从更新日志文件预取的日志条目数。

​

NaiveBayesClassifierModelsAllocatedBytes

已废弃的事件，用于统计朴素贝叶斯分类器模型已分配的字节数。

​

NaiveBayesClassifierModelsLoaded

已废弃的事件，用于统计已加载的朴素贝叶斯分类器模型数。

​

ReaderExecutorRequestedBytes

已废弃的事件，用于统计 ReaderExecutor 读取请求所提供的有效字节数。

​

列

• 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 监控的基本概念。