跳转到主内容
跳转到主内容

system.events

在 ClickHouse Cloud 中进行查询

该系统表中的数据保存在 ClickHouse Cloud 中每个节点的本地。因此，如需获得所有数据的完整视图，需要使用 clusterAllReplicas 函数。更多详情请参阅此处。

包含有关系统中已发生事件数量的信息。例如，在该表中，您可以查看自 ClickHouse 服务器启动以来已处理了多少个 SELECT 查询。

列：

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

示例

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.                                                                                                                                              │
└───────────────────────────────────────┴───────┴────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘

事件描述​

ACMEAPIRequests​

发起的 ACME API 请求数量。

ACMECertificateOrders​

已创建的 ACME 证书订单数量。

AIORead​

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

AIOReadBytes​

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

AIOWrite​

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

AIOWriteBytes​

使用 Linux 或 FreeBSD AIO 接口写入的字节数

ASTFuzzerQueries​

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

AddressesDiscovered​

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

地址已过期​

HTTP 连接的 DNS 解析结果中已不再出现的过期地址总数

AddressesMarkedAsFailed​

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

AggregatingSortedMilliseconds​

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

聚合时初始化为两级的哈希表数量​

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

AggregationOptimizedEqualRangesOfKeys​

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

聚合哈希表中预分配的元素数​

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

AnalyzePatchRangesMicroseconds​

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

ApplyPatchesMicroseconds​

将补丁分区片段应用到数据块所花费的总时间

ArenaAllocBytes​

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

ArenaAllocChunks​

为内存 Arena 分配的фрагменты数量 (用于 GROUP BY 等类似操作)

AsyncInsertBytes​

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

AsyncInsertCacheHits​

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

AsyncInsertQuery​

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

AsyncInsertRows​

异步 INSERT 查询插入的行数。

AsyncLoaderWaitMicroseconds​

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

AsyncLoggingConsoleDroppedMessages​

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

AsyncLoggingConsoleTotalMessages​

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

AsyncLoggingErrorFileLogDroppedMessages​

错误 File 日志中因异步日志队列已满而被丢弃的消息数量

AsyncLoggingErrorFileLogTotalMessages​

发送到错误 File 日志异步队列的消息总数（包括已接受和已丢弃的消息）

AsyncLoggingFileLogDroppedMessages​

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

AsyncLoggingFileLogTotalMessages​

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

AsyncLoggingSyslogDroppedMessages​

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

AsyncLoggingSyslogTotalMessages​

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

AsyncLoggingTextLogDroppedMessages​

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

AsyncLoggingTextLogTotalMessages​

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

异步读取等待微秒数​

在异步本地读取期间，等待异步读取所耗费的时间。

AsynchronousReaderIgnoredBytes​

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

AsynchronousRemoteReadWaitMicroseconds​

等待异步远程读取所花费的时间。

AzureCommitBlockList​

Azure Blob 存储 API CommitBlockList 调用次数

AzureCopyObject​

Azure Blob 存储 API 中 CopyObject 的调用次数

AzureCreateContainer​

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

AzureDeleteObjects​

Azure Blob 存储 API DeleteObject(s) 的调用次数。

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' File 的次数

BackupPreparingFileInfosMicroseconds​

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

BackupReadLocalBytesToCalculateChecksums​

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

BackupReadLocalFilesToCalculateChecksums​

为计算备份条目的校验和而在本地读取的 File 数量

BackupReadMetadataMicroseconds​

从 .backup File 读取备份元数据所耗费的时间

BackupReadRemoteBytesToCalculateChecksums​

从远程磁盘读取以计算备份条目校验和的 File 总大小

BackupReadRemoteFilesToCalculateChecksums​

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

BackupThrottlerBytes​

通过“max_backup_bandwidth_for_server”限流器的字节数。

BackupThrottlerSleepMicroseconds​

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

BackupWriteMetadataMicroseconds​

将备份元数据写入 .backup File 所用的时间

BackupsOpenedForRead​

已打开以供读取的备份数量

BackupsOpenedForUnlock​

为执行解锁而打开的备份数

BackupsOpenedForWrite​

已打开用于写入操作的备份数量

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 删除错误数

BlobKillerThreadRemoveTasks​

由 BlobKiller 创建的删除任务数量

BlobKillerThreadRemovedBlobs​

BlobKiller 删除的 Blob 数量

BlobKillerThreadRuns​

BlobKiller 线程执行次数

BuildPatchesJoinMicroseconds​

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

BuildPatchesMergeMicroseconds​

以 Merge 模式应用补丁分区片段时构建索引所花费的总时间

CacheWarmerBytesDownloaded​

由专用后台线程获取并加载到文件系统缓存中的数据量。

CacheWarmerDataPartsDownloaded​

由 CacheWarmer 完整获取的分区片段数量。

CachedReadBufferCacheWriteBytes​

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

CachedReadBufferCacheWriteMicroseconds​

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

CachedReadBufferCreateBufferMicroseconds​

缓冲区准备时间

CachedReadBufferPredownloadedBytes​

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

CachedReadBufferPredownloadedFromSourceBytes​

为预下载而从文件系统缓存源 (如远程 fs 等) 读取的字节数

CachedReadBufferPredownloadedFromSourceMicroseconds​

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

CachedReadBufferReadFromCacheBytes​

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

CachedReadBufferReadFromCacheHits​

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

CachedReadBufferReadFromCacheMicroseconds​

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

CachedReadBufferReadFromCacheMisses​

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

CachedReadBufferReadFromSourceBytes​

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

CachedReadBufferReadFromSourceMicroseconds​

从文件系统缓存源（如远程文件系统等）读取所花费的时间

CachedReadBufferWaitReadBufferMicroseconds​

等待内部读取缓冲区的耗时（包括缓存等待时间）

CachedWriteBufferCacheWriteBytes​

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

CachedWriteBufferCacheWriteMicroseconds​

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

CannotRemoveEphemeralNode​

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

CannotWriteToWriteBufferDiscard​

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

CoalescingSortedMilliseconds​

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

CollapsingSortedMilliseconds​

折叠已排序列所花费的总时间

CommonBackgroundExecutorTaskCancelMicroseconds​

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

CommonBackgroundExecutorTaskExecuteStepMicroseconds​

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

CommonBackgroundExecutorTaskResetMicroseconds​

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

CommonBackgroundExecutorWaitMicroseconds​

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

CompileExpressionsBytes​

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

CompileExpressionsMicroseconds​

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

CompileFunction​

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

CompiledFunctionExecute​

编译后函数的执行次数。

CompressedReadBufferBlocks​

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

CompressedReadBufferBytes​

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

CompressedReadBufferChecksumDoesntMatch​

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

CompressedReadBufferChecksumDoesntMatchMicroseconds​

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

CompressedReadBufferChecksumDoesntMatchSingleBitMismatch​

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

ConcurrencyControlDownscales​

CPU 下调事件总数

ConcurrencyControlPreemptedMicroseconds​

由于 CPU 槽位被抢占，查询处于等待状态的总时长。

ConcurrencyControlPreemptions​

CPU 被抢占总次数

ConcurrencyControlQueriesDelayed​

因等待槽位扩容而需要等待的 CPU 槽位分配 (查询) 总数

ConcurrencyControlSlotsAcquired​

获取的 CPU 槽位总数

ConcurrencyControlSlotsAcquiredNonCompeting​

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

ConcurrencyControlSlotsDelayed​

初始未获分配、需要等待空闲 CPU 槽位的 CPU 槽位数量

ConcurrencyControlSlotsGranted​

根据“每个查询保证 1 个线程”以及针对设置 'use_concurrency_control' = 0 的查询而授予的 CPU 槽位数量

ConcurrencyControlUpscales​

CPU 扩容事件总数

ConcurrencyControlWaitMicroseconds​

查询等待 CPU 槽位资源请求的总时间。

ConcurrentQuerySlotsAcquired​

获取到的查询槽位总数

ConcurrentQueryWaitMicroseconds​

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

ConnectionPoolIsFullMicroseconds​

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

ContextLock​

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

ContextLockWaitMicroseconds​

上下文锁等待时间 (微秒)

CoordinatedMergesMergeAssignmentRequest​

合并任务分配请求总数

CoordinatedMergesMergeAssignmentRequestMicroseconds​

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

CoordinatedMergesMergeAssignmentResponse​

合并任务分配请求总数

CoordinatedMergesMergeAssignmentResponseMicroseconds​

合并分配处理器中耗费的总时间

CoordinatedMergesMergeCoordinatorFetchMetadataMicroseconds​

在 merge coordinator 内部获取最新元数据的总耗时

CoordinatedMergesMergeCoordinatorFilterMicroseconds​

在 merge coordinator 中筛选已准备就绪的合并所耗费的总时间

CoordinatedMergesMergeCoordinatorLockStateExclusivelyCount​

独占获取 coordinator 状态锁的总次数

CoordinatedMergesMergeCoordinatorLockStateExclusivelyMicroseconds​

以独占方式锁定 coordinator 状态互斥锁所花费的总时间

CoordinatedMergesMergeCoordinatorLockStateForShareCount​

对 coordinator 状态锁执行 FOR SHARE 捕获的总次数

CoordinatedMergesMergeCoordinatorLockStateForShareMicroseconds​

为共享操作锁定 coordinator 状态互斥锁的总耗时

CoordinatedMergesMergeCoordinatorSelectMergesMicroseconds​

在 merge coordinator 中使用 merge selector 查找 merge 的总耗时

CoordinatedMergesMergeCoordinatorUpdateCount​

merge coordinator 的更新总次数

CoordinatedMergesMergeCoordinatorUpdateMicroseconds​

更新 merge coordinator 状态所花费的总时间

CoordinatedMergesMergeWorkerUpdateCount​

合并工作线程更新总数

CoordinatedMergesMergeWorkerUpdateMicroseconds​

worker 更新已分配合并任务的本地状态所花费的总时间

CreatedLogEntryForMerge​

已成功创建用于合并 ReplicatedMergeTree 中分区片段的日志条目。

CreatedLogEntryForMutation​

已成功创建用于变更 ReplicatedMergeTree 中分区片段的日志条目。

CreatedReadBufferDirectIO​

在读取数据时 (在多种读取方法中选择时) 创建带有 O_DIRECT 的读取缓冲区的次数。

CreatedReadBufferDirectIOFailed​

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

CreatedReadBufferMMap​

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

CreatedReadBufferMMapFailed​

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

CreatedReadBufferOrdinary​

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

DNSError​

DNS 解析错误总数

DataAfterMergeDiffersFromReplica​

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

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

DataAfterMutationDiffersFromReplica​

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

DefaultImplementationForNullsRows​

函数执行期间，null 值默认实现处理的行数

DefaultImplementationForNullsRowsWithNulls​

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

DelayedInserts​

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

DelayedInsertsMilliseconds​

因分区中的活跃数据片段数量过多，向 MergeTree 表 INSERT 数据块时被限流而累计耗费的总毫秒数。

DelayedMutations​

由于表中未完成的变更过多，MergeTree 表的变更被限流的次数。

DelayedMutationsMilliseconds​

由于表中未完成的变更数量过多，MergeTree 表的变更在被限流期间所花费的 Milliseconds 总数。

DeltaLakePartitionPrunedFiles​

DeltaLake 分区裁剪期间跳过的 File 数

DeltaLakeScannedFiles​

在 DeltaLake 扫描回调期间扫描的 File 数量

DeltaLakeSnapshotInitializations​

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

DictCacheKeysExpired​

在类型为 '缓存' 的字典中查找到、且在缓存中命中但已过时的键的数量。

DictCacheKeysHit​

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

DictCacheKeysNotFound​

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

DictCacheKeysRequested​

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

DictCacheKeysRequestedFound​

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

DictCacheKeysRequestedMiss​

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

DictCacheLockReadNs​

查找“缓存”类型的字典数据时，等待获取读锁所耗费的纳秒数。

DictCacheLockWriteNs​

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

DictCacheRequestTimeNs​

查询 'cache' 类型字典的外部数据源时花费的纳秒数。

DictCacheRequests​

“缓存”类型的字典向外部数据源发起的批量请求数。

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 的 Upload 调用次数

DiskAzureWriteMicroseconds​

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

DiskAzureWriteRequestsCount​

Azure 磁盘写入请求数。

DiskAzureWriteRequestsErrors​

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

DiskAzureWriteRequestsRedirects​

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

DiskAzureWriteRequestsThrottling​

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

DiskConnectionsCreated​

为磁盘创建的连接数

DiskConnectionsElapsedMicroseconds​

为磁盘创建连接的总耗时

DiskConnectionsErrors​

磁盘连接创建失败的次数

DiskConnectionsExpired​

磁盘的过期连接数

DiskConnectionsPreserved​

磁盘保留连接数

DiskConnectionsReset​

磁盘已重置的连接数

DiskConnectionsReused​

磁盘复用连接数

DiskPlainRewritableAzureDirectoryCreated​

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

DiskPlainRewritableAzureDirectoryRemoved​

AzureObjectStorage 的 plain_rewritable 元数据存储删除的目录数量。

DiskPlainRewritableLegacyLayoutDiskCount​

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

DiskPlainRewritableLocalDirectoryCreated​

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

DiskPlainRewritableLocalDirectoryRemoved​

LocalObjectStorage 的 'plain_rewritable' 元数据存储已移除的目录数量。

DiskPlainRewritableS3DirectoryCreated​

由用于 S3ObjectStorage 的 plain_rewritable 元数据存储创建的目录数。

DiskPlainRewritableS3DirectoryRemoved​

S3ObjectStorage 的 plain_rewritable 元数据存储删除的目录数量。

DiskReadElapsedMicroseconds​

等待 read syscall 的总耗时。这包括从页缓存进行的读取。

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​

等待 write 系统调用所花费的总时间，包括写入页缓存的操作。

DistrCacheConnectAttempts​

分布式缓存创建事件。对分布式缓存的创建尝试次数

DistrCacheConnectMicroseconds​

分布式缓存创建事件。连接到分布式缓存所花费的时间

DistrCacheFallbackReadMicroseconds​

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

DistrCacheGetClientMicroseconds​

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

DistrCacheGetResponseMicroseconds​

分布式缓存客户端事件。等待分布式缓存响应所耗费的时间

DistrCacheHashRingRebuilds​

分布式缓存注册事件。分布式缓存哈希环重建次数

DistrCacheLockRegistryMicroseconds​

分布式缓存注册表事件。获取 DistributedCacheRegistry 锁的耗时

DistrCacheMakeRequestErrors​

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

DistrCacheNextImplMicroseconds​

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

DistrCacheOpenedConnections​

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

DistrCacheOpenedConnectionsBypassingPool​

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

DistrCachePrecomputeRangesMicroseconds​

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

DistrCacheRangeChange​

分布式缓存读取缓冲区事件。因 seek/last_position 变化而更改读取范围的次数

DistrCacheRangeResetBackward​

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

DistrCacheRangeResetForward​

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

DistrCacheReadBytesFromFallbackBuffer​

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

DistrCacheReadErrors​

分布式缓存读取缓冲区事件。读取期间发生的分布式缓存错误数量

DistrCacheReadMicroseconds​

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

DistrCacheReadThrottlerBytes​

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

DistrCacheReadThrottlerSleepMicroseconds​

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

DistrCacheReceiveResponseErrors​

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

DistrCacheReceivedCredentialsRefreshPackets​

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

DistrCacheReceivedDataPackets​

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

DistrCacheReceivedDataPacketsBytes​

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

DistrCacheReceivedErrorPackets​

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

DistrCacheReceivedOkPackets​

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

DistrCacheReceivedStopPackets​

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

DistrCacheReconnectsAfterTimeout​

分布式缓存读缓冲区事件。超时后重新连接的次数

DistrCacheRegistryUpdateMicroseconds​

分布式缓存注册表事件。更新分布式缓存注册表的耗时

DistrCacheRegistryUpdates​

分布式缓存注册表事件。分布式缓存注册表更新的次数

DistrCacheReusedConnections​

分布式缓存创建事件。到分布式缓存的复用连接数

DistrCacheSentDataPackets​

分布式缓存客户端事件。发送到分布式缓存的数据包总数

DistrCacheSentDataPacketsBytes​

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

DistrCacheServerAckRequestPackets​

分布式缓存服务器事件。DistributedCacheServer 中 AckRequest 数据包的数量。

DistrCacheServerCachedReadBufferCacheHits​

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

DistrCacheServerCachedReadBufferCacheMisses​

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

DistrCacheServerCachedReadBufferCachePredownloadBytes​

分布式缓存服务器事件。在从文件系统缓存读取期间，为在分布式缓存中进行预下载而从对象存储读取的字节数

DistrCacheServerCachedReadBufferCacheReadBytes​

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

DistrCacheServerCachedReadBufferCacheWrittenBytes​

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

DistrCacheServerCachedReadBufferObjectStorageReadBytes​

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

DistrCacheServerContinueRequestPackets​

分布式缓存服务器事件。DistributedCacheServer 中 ContinueRequest 数据包数量

DistrCacheServerCredentialsRefresh​

分布式缓存服务器事件。已更新过期凭据的计数

DistrCacheServerEndRequestPackets​

分布式缓存服务器事件。DistributedCacheServer 中 EndRequest 数据包的数量

DistrCacheServerNewS3CachedClients​

分布式缓存服务器事件。新增缓存的 S3 客户端数量

DistrCacheServerProcessRequestMicroseconds​

分布式缓存服务器事件。在分布式缓存服务器端处理请求所花费的时间

DistrCacheServerReceivedCredentialsRefreshPackets​

分布式缓存服务器事件。DistributedCacheServer 中 RefreshCredentials 客户端数据包的接收数量

DistrCacheServerReusedS3CachedClients​

分布式缓存服务器事件。被复用的已缓存 S3 客户端数量

DistrCacheServerSkipped​

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

DistrCacheServerStartRequestPackets​

分布式缓存服务器事件。DistributedCacheServer 中 StartRequest 包的数量

DistrCacheServerSwitches​

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

DistrCacheServerUpdates​

分布式缓存读取缓冲区事件。由于服务器不再在 Keeper 中注册而发生的服务器更新次数

DistrCacheStartRangeMicroseconds​

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

DistrCacheSuccessfulConnectAttempts​

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

DistrCacheSuccessfulRegistryUpdates​

分布式缓存注册表事件。服务器注册表成功更新的次数

DistrCacheTemporaryFilesBytesWritten​

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

DistrCacheTemporaryFilesCreated​

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

DistrCacheUnsuccessfulConnectAttempts​

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

DistrCacheUnsuccessfulRegistryUpdates​

分布式缓存注册表事件。服务器注册表更新失败次数

DistrCacheUnusedDataPacketsBytes​

分布式缓存客户端事件。已忽略的 Data 数据包的字节数

DistrCacheUnusedPackets​

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

DistrCacheUnusedPacketsBufferAllocations​

分布式缓存客户端事件。无法重用现有缓冲区时，额外分配缓冲区的次数

DistrCacheWriteErrors​

分布式缓存写入缓冲区事件。写入期间发生的分布式缓存错误数量

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​

因待处理字节数过多，向分布式表 INSERT 数据块时被限流的次数。

DistributedDelayedInsertsMilliseconds​

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

DistributedIndexAnalysisMicroseconds​

分布式索引分析期间的总耗时

DistributedIndexAnalysisMissingParts​

分布式索引分析期间将在本地处理的缺失分区片段数量

DistributedIndexAnalysisParts​

发送用于分布式索引分析的分区片段数

DistributedIndexAnalysisReplicaFallback​

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

DistributedIndexAnalysisReplicaUnavailable​

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

DistributedIndexAnalysisScheduledReplicas​

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

DistributedRejectedInserts​

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

DistributedSyncInsertionTimeoutExceeded​

在向分布式表进行同步插入时，等待分片的过程中发生超时 ('distributed_foreground_insert' = 1)

DuplicatedAsyncInserts​

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

DuplicatedInsertedBlocks​

对 *MergeTree 表执行的同步插入被去重的次数。

DuplicationElapsedMicroseconds​

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

EngineFileLikeReadFiles​

使用 File 的表引擎（如 File/S3/URL/HDFS）读取的 File 数。

执行 Shell 命令​

执行 Shell 命令的次数。

ExternalAggregationCompressedBytes​

在外部内存中进行聚合时写入磁盘的字节数。

ExternalAggregationMerge​

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

ExternalAggregationUncompressedBytes​

为外部内存聚合而写入磁盘的数据量 (未压缩，即压缩前) 。

ExternalAggregationWritePart​

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

ExternalDataSourceLocalCacheReadBytes​

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

ExternalJoinCompressedBytes​

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

ExternalJoinMerge​

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

ExternalJoinUncompressedBytes​

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

ExternalJoinWritePart​

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

ExternalProcessingCompressedBytesTotal​

由外部处理 (排序/聚合/join) 写入的压缩字节数

ExternalProcessingFilesTotal​

外部处理 (排序/聚合/join) 使用的 File 数量

ExternalProcessingUncompressedBytesTotal​

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

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 执行器任务在 executeStep() 中耗费的时间。

FetchBackgroundExecutorTaskResetMicroseconds​

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

FetchBackgroundExecutorWaitMicroseconds​

在 Fetch 执行器中等待任务完成所花费的时间。

FileOpen​

打开的 File 数。

FileSegmentCompleteMicroseconds​

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

FileSegmentFailToIncreasePriority​

由于缓存锁竞争激烈而未能提升优先级的次数

FileSegmentHolderCompleteMicroseconds​

File segments 持有器 complete() 耗时

FileSegmentIncreasePriorityMicroseconds​

File 段优先级提升时间

FileSegmentLockMicroseconds​

锁定 File 段的耗时

FileSegmentRemoveMicroseconds​

File 段执行 remove() 的耗时

FileSegmentWaitMicroseconds​

等待处于 DOWNLOADING 状态的时间

FileSegmentWriteMicroseconds​

File 段 write() 耗时

FileSync​

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

FileSyncElapsedMicroseconds​

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

FilesystemCacheBackgroundDownloadQueuePush​

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

FilesystemCacheBackgroundEvictedBytes​

被后台线程逐出的字节数

FilesystemCacheBackgroundEvictedFileSegments​

被后台线程逐出的 File 段数量

FilesystemCacheCheckCorrectness​

FileCache::assertCacheCorrectness 被调用的次数

FilesystemCacheCheckCorrectnessMicroseconds​

FileCache::assertCacheCorrectness 所耗费的时间

FilesystemCacheCreatedKeyDirectories​

已创建的键目录数

FilesystemCacheEvictMicroseconds​

文件系统缓存淘汰时间

FilesystemCacheEvictedBytes​

从文件系统缓存中逐出的字节数

FilesystemCacheEvictedFileSegments​

从文件系统缓存中被逐出的 File 段数量

FilesystemCacheEvictedFileSegmentsDuringPriorityIncrease​

提高 File 段优先级时，从文件系统缓存中被逐出的 File 段数量（适用于 SLRU 缓存策略）

FilesystemCacheEvictionReusedIterator​

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

FilesystemCacheEvictionSkippedEvictingFileSegments​

因处于 evicting 状态而跳过淘汰的 File 段数量

FilesystemCacheEvictionSkippedFileSegments​

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

FilesystemCacheEvictionSkippedMovingFileSegments​

因处于移动状态而跳过淘汰的 File 段数量

FilesystemCacheEvictionTries​

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

FilesystemCacheFailToReserveSpaceBecauseOfCacheResize​

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

FilesystemCacheFailToReserveSpaceBecauseOfLockContention​

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

FilesystemCacheFailedEvictionCandidates​

动态文件系统缓存淘汰过程中意外未能被逐出的文件段数量

FilesystemCacheFreeSpaceKeepingThreadRun​

后台线程执行空闲空间维护作业的次数

FilesystemCacheFreeSpaceKeepingThreadWorkMilliseconds​

后台线程执行空闲空间保持作业的耗时

FilesystemCacheGetMicroseconds​

文件系统缓存 get() 耗时

FilesystemCacheGetOrSetMicroseconds​

文件系统缓存 getOrSet() 耗时

文件系统缓存中被持有的 File 段​

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

FilesystemCacheLoadMetadataMicroseconds​

导入文件系统缓存元数据所花费的时间

FilesystemCacheLockKeyMicroseconds​

锁定缓存键的耗时。

FilesystemCacheLockMetadataMicroseconds​

锁定文件系统缓存元数据耗时

FilesystemCachePriorityReadLockMicroseconds​

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

FilesystemCachePriorityWriteLockMicroseconds​

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

FilesystemCacheReserveAttempts​

文件系统缓存空间预留尝试操作

FilesystemCacheReserveMicroseconds​

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

FilesystemCacheStateLockMicroseconds​

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

FilesystemCacheUnusedHoldFileSegments​

文件系统缓存中被保留但未使用的 File 段数量 (例如由于 seek 或 LIMIT n 等)

FilterPartsByVirtualColumnsMicroseconds​

filterPartsByVirtualColumns 函数耗费的总时间。

FilterTransformPassedBytes​

查询中通过过滤器的字节数

FilterTransformPassedRows​

查询中过滤后保留的行数

FilteringMarksWithPrimaryKeyMicroseconds​

通过主键过滤分区片段所花费的时间。

使用二级键过滤 marks 的耗时 (微秒)​

通过 skip 索引过滤分区片段所花费的时间。

FunctionExecute​

SQL 普通函数调用次数 (SQL 函数按数据块调用，因此该数字表示数据块的数量) 。

GatheredColumns​

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

GatheringColumnMilliseconds​

垂直合并过程中收集列所耗费的总时间

GlobalThreadPoolExpansions​

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

GlobalThreadPoolJobWaitTimeMicroseconds​

衡量作业在线程池中被调度后，到被工作线程取走并开始执行之间经过的时间。此指标有助于识别作业处理延迟，反映线程池对新任务的响应速度。

GlobalThreadPoolJobs​

统计已推送到全局线程池中的作业数量。

GlobalThreadPoolLockWaitMicroseconds​

全局线程池中的线程等待锁所花费的总时间。

GlobalThreadPoolShrinks​

统计全局线程池通过移除线程而收缩的总次数。当空闲线程数量超过 max_thread_pool_free_size 时，就会发生这种情况，表明全局线程池的大小会因线程利用率下降而进行调整。

GlobalThreadPoolThreadCreationMicroseconds​

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

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 连接数

硬缺页​

查询执行线程中的硬缺页数量。数值较高通常表明：要么你忘记在服务器上关闭 swap，要么是在极高内存压力下 ClickHouse 二进制文件的内存页被换出，要么是成功使用了表数据的 mmap 读取方式。

HashJoinPreallocatedElementsInHashTables​

用于 hash join 的哈希表中预先分配的元素数量。

HedgedRequestsChangeReplica​

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

IOBufferAllocBytes​

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

IOBufferAllocs​

ReadBuffer/WriteBuffer 所用 IO 缓冲区的分配次数。

IOUringCQEsCompleted​

成功完成的 io_uring CQE 总数

IOUringCQEsFailed​

执行完成但失败的 io_uring CQE 总数

IOUringSQEsResubmitsAsync​

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

IOUringSQEsResubmitsSync​

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

IOUringSQEsSubmitted​

提交的 io_uring SQE 总数

IcebergIteratorInitializationMicroseconds​

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

IcebergMetadataFilesCacheHits​

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

IcebergMetadataFilesCacheMisses​

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

IcebergMetadataFilesCacheWeightLost​

从 Iceberg 元数据缓存中淘汰的估算字节数。

IcebergMetadataReadWaitTimeMicroseconds​

数据读取器等待 Iceberg 元数据 File 被读取和解析所花费的总时间，在所有读取器线程数量上求和。

IcebergMetadataReturnedObjectInfos​

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

IcebergMetadataUpdateMicroseconds​

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

IcebergMinMax索引剪枝的文件​

在 Iceberg 中使用 MinMax 索引跳过的 File 数量

IcebergMinMaxNonPrunedDeleteFiles​

通过 minmax 分析，在按分区和序列号筛选出的适用文件对中，被接受的数据文件-位置删除文件对总数。

IcebergMinMaxPrunedDeleteFiles​

通过 minmax 分析，从按分区和序列号筛选后的配对中接受的数据 File-位置删除 File 对总数。

IcebergPartitionPrunedFiles​

Iceberg 分区裁剪期间被跳过的 File 数量

IcebergTrivialCountOptimizationApplied​

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

IcebergVersionHintUsed​

version-hint.text 的使用次数。

IgnoredColdParts​

请参阅设置 ignore_cold_parts_seconds。读取查询忽略尚未被 CacheWarmer 拉入缓存的较新分区片段的次数。

IndexAnalysisRounds​

查询期间执行索引分析的次数。

索引二分查找算法​

对索引标记使用二分查找算法的次数

IndexGenericExclusionSearchAlgorithm​

对索引标记使用通用排除搜索算法的次数

InitialQuery​

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

InitialSelectQuery​

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

InsertQueriesWithSubqueries​

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

InsertQuery​

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

InsertQueryTimeMicroseconds​

INSERT 查询耗费的总时间。

InsertedBytes​

INSERT 到所有表的字节数 (未压缩；对于列，按其在内存中的存储形式计算) 。

InsertedCompactParts​

以 Compact 格式插入的分区片段数。

已插入的行数​

向所有表 INSERT 的行数。

InsertedWideParts​

以 Wide 格式插入的分区片段数。

InterfaceHTTPReceiveBytes​

通过 HTTP 接口接收的字节数

InterfaceHTTPSendBytes​

通过 HTTP 接口发送的字节数

InterfaceInterserverReceiveBytes​

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

InterfaceInterserverSendBytes​

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

InterfaceMySQLReceiveBytes​

通过 MySQL 接口接收的字节数

InterfaceMySQLSendBytes​

通过 MySQL 接口发送的字节数

InterfaceNativeReceiveBytes​

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

InterfaceNativeSendBytes​

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

InterfacePostgreSQLReceiveBytes​

通过 PostgreSQL 接口接收的字节数

InterfacePostgreSQLSendBytes​

通过 PostgreSQL 接口发送的字节数

InterfacePrometheusReceiveBytes​

通过 Prometheus 接口接收的字节数

InterfacePrometheusSendBytes​

通过 Prometheus 接口发送的字节数

JemallocFailedAllocationSampleTracking​

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

JemallocFailedDeallocationSampleTracking​

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

JoinBuildTableRowCount​

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

JoinOptimizeMicroseconds​

执行 JOIN 计划优化的总耗时。

JoinProbeTableRowCount​

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

JoinReorderMicroseconds​

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

JoinResultRowCount​

JOIN 操作结果中的行总数。

KafkaBackgroundReads​

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

KafkaCommitFailures​

向 Kafka 提交已消费偏移量失败的次数 (通常表明可能存在数据重复)

KafkaCommits​

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

KafkaConsumerErrors​

librdkafka 在轮询时报告的错误数量

KafkaDirectReads​

自服务器启动以来，直接从 Kafka 表执行的查询次数

KafkaMVNotReady​

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

KafkaMessagesFailed​

ClickHouse 解析 Kafka 失败的消息数量

KafkaMessagesPolled​

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

KafkaMessagesProduced​

发送到 Kafka 的消息数量

KafkaMessagesRead​

ClickHouse 已处理的 Kafka 消息数

KafkaProducerErrors​

向 Kafka 生产消息过程中发生的错误数量

KafkaProducerFlushes​

Kafka 生产者显式执行 flush 的次数

KafkaRebalanceAssignments​

分区分配数 (消费者组再均衡的最终阶段)

KafkaRebalanceErrors​

消费者组再均衡失败次数

KafkaRebalanceRevocations​

分区撤销的次数 (消费者组再均衡的第一阶段)

KafkaRowsRead​

从 Kafka 消息中解析出的行数

KafkaRowsRejected​

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

Kafka写入行数​

写入 Kafka 表的行数

KafkaWrites​

Kafka 表的写入 (插入) 次数

KeeperAddWatchRequest​

添加监视请求数

KeeperBatchMaxCount​

批次大小因数量限制而受限的次数

KeeperBatchMaxTotalSize​

批次大小因总字节数限制而受限的次数

KeeperChangelogFileSyncMicroseconds​

Keeper 更新日志执行 fsync 所耗费的时间（仅适用于未压缩日志）

KeeperChangelogWrittenBytes​

Keeper 中写入更新日志的字节数

KeeperCheckRequest​

检查请求的数量

KeeperCheckWatchRequest​

移除监视请求数

KeeperCommitWaitElapsedMicroseconds​

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

KeeperCommits​

成功提交次数

KeeperCommitsFailed​

提交失败次数

KeeperCreateRequest​

创建请求数

KeeperExistsRequest​

exists 请求数量

KeeperFinishedSessionsCacheFull​

因缓存达到大小限制而无法跟踪已结束会话的次数

KeeperGetRequest​

Get 请求数

KeeperLatency​

Keeper 延迟

KeeperListRequest​

列表请求数

KeeperLogsEntryReadFromCommitCache​

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

KeeperLogsEntryReadFromFile​

Keeper 中直接从更新日志 File 读取的日志条目数量

KeeperLogsEntryReadFromLatestCache​

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

KeeperLogsPrefetchedEntries​

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

KeeperMultiReadRequest​

批量读取请求数

KeeperMultiRequest​

多请求数量

KeeperPacketsReceived​

Keeper 服务器接收的数据包数

KeeperPacketsSent​

Keeper 服务器发送的数据包

KeeperPreprocessElapsedMicroseconds​

单个请求的 Keeper 预处理延迟

KeeperProcessElapsedMicroseconds​

单个请求的 Keeper 提交延迟

KeeperReadSnapshot​

读取快照的次数 (序列化)

KeeperReconfigRequest​

重配置请求数

KeeperRemoveRequest​

删除请求数量

KeeperRemoveWatchRequest​

移除监视请求的数量

KeeperRequestRejectedDueToSoftMemoryLimitCount​

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

KeeperRequestTotal​

Keeper 服务器上的请求总数

KeeperRequestTotalWithSubrequests​

Keeper 服务器上的请求总数，其中多重请求中的每个子请求都会分别计数

KeeperSaveSnapshot​

快照保存次数

KeeperSetRequest​

Set 请求数量

KeeperSetWatchesRequest​

设置监视请求的数量

KeeperSnapshotApplys​

应用快照的次数

KeeperSnapshotApplysFailed​

应用快照失败的次数

KeeperSnapshotCreations​

创建快照的次数

KeeperSnapshotCreationsFailed​

快照创建失败次数

KeeperSnapshotFileSyncMicroseconds​

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

KeeperSnapshotWrittenBytes​

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

KeeperStaleRequestsSkipped​

因 session 已结束而跳过的 Keeper 请求数量

KeeperStorageLockWaitMicroseconds​

等待获取 Keeper 存储锁所花费的时间

KeeperTotalElapsedMicroseconds​

单次请求的 Keeper 总延迟

LoadedDataParts​

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

LoadedDataPartsMicroseconds​

MergeTree 表在初始化期间加载数据分区片段耗费的微秒数。

已加载标记数​

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

LoadedMarksFiles​

已加载的标记 File 数量。

LoadedMarksMemoryBytes​

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

LoadedPrimaryIndexBytes​

已加载的主键的行数。

LoadedPrimaryIndexFiles​

已加载的主键索引 File 数量。

LoadedPrimaryIndexRows​

已加载的主键行数。

LoadedStatisticsMicroseconds​

从分区片段加载统计信息的耗时

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​

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

LocalThreadPoolJobWaitTimeMicroseconds​

衡量作业在线程池中被调度后，到被工作线程取走执行为止所经过的时间。此指标有助于识别作业处理中的延迟，从而反映线程池对新任务的响应速度。

LocalThreadPoolJobs​

表示已推送到本地线程池中的作业数量。

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 级别日志消息的数量

LogInfo​

Info 级别日志消息的数量

LogTest​

Test 级别的日志消息数量

LogTrace​

Trace 级别的日志消息数量

LogWarning​

日志级别为 Warning 的消息数量

LoggerElapsedNanoseconds​

用于日志记录的累计耗时

MMappedFileCacheHits​

在 MMap 缓存中找到某个 File 的次数（针对 mmap 读取方法），因此无需再次对其执行 mmap。

MMappedFileCacheMisses​

在 MMap 缓存中未找到 File 的次数（针对 mmap read_method），因此必须再次对其执行 mmap。

MainConfigLoads​

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

MarkCacheEvictedBytes​

从 mark 缓存中驱逐的字节数。

MarkCacheEvictedFiles​

从 mark 缓存中驱逐的 mark 文件数量。

MarkCacheEvictedMarks​

从 mark 缓存中驱逐的标记数量。

MarkCacheHits​

在 mark 缓存中找到条目的次数，因此无需加载 mark 文件。

MarkCacheMisses​

条目未在 mark 缓存中找到、因此不得不将 mark 文件加载到内存中的次数。该操作开销较大，会增加查询延迟。

MarksTasksFromCache​

由于标记已存在于缓存中而被同步加载的次数。

MemoryAllocatedWithoutCheck​

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

MemoryAllocatedWithoutCheckBytes​

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

MemoryAllocatorPurge​

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

内存分配器清理时间 (微秒)​

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

MemoryOvercommitWaitTimeMicroseconds​

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

MemoryWorkerRun​

MemoryWorker 在后台执行的次数

MemoryWorkerRunElapsedMicroseconds​

MemoryWorker 执行后台工作的总耗时

Merge​

已启动的后台合并次数。

MergeExecuteMilliseconds​

执行后台合并所花费的总繁忙时间

MergeHorizontalStageExecuteMilliseconds​

后台合并执行水平阶段所消耗的总繁忙时间

MergeHorizontalStageTotalMilliseconds​

后台合并中水平阶段耗费的总时间

MergeMutateBackgroundExecutorTaskCancelMicroseconds​

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

MergeMutateBackgroundExecutorTaskExecuteStepMicroseconds​

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

MergeMutateBackgroundExecutorTaskResetMicroseconds​

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

MergeMutateBackgroundExecutorWaitMicroseconds​

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

MergePrewarmStageExecuteMilliseconds​

执行后台合并的 prewarm 阶段所耗费的总繁忙时间

MergePrewarmStageTotalMilliseconds​

后台合并的 prewarm 阶段总耗时

MergeProjectionStageExecuteMilliseconds​

后台合并期间执行 PROJECTION 阶段所耗费的总繁忙时间

MergeProjectionStageTotalMilliseconds​

后台合并中 PROJECTION 阶段所耗费的总时间

MergeSourceParts​

计划合并的源分区片段数量。

MergeTextIndexStageExecuteMilliseconds​

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

MergeTextIndexStageTotalMilliseconds​

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

MergeTotalMilliseconds​

后台合并所花费的总时间

MergeTreeAllRangesAnnouncementsSent​

远程服务器向发起方服务器发送的、关于数据分区片段集合 (针对 MergeTree 表) 的通知数量。在远程服务器端测量。

MergeTreeAllRangesAnnouncementsSentElapsedMicroseconds​

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

MergeTreeDataProjectionWriterBlocks​

INSERT 到 MergeTree 表 PROJECTION 中的数据块数量。每个数据块都会形成一个零级数据分片。

MergeTreeDataProjectionWriterBlocksAlreadySorted​

INSERT 到 MergeTree 表 PROJECTION 中且似乎已排序的数据块数量。

MergeTreeDataProjectionWriterCompressedBytes​

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

MergeTreeDataProjectionWriterMergingBlocksMicroseconds​

合并数据块所用的时间

MergeTreeDataProjectionWriterRows​

INSERT 到 MergeTree 表 PROJECTION 中的行数。

MergeTreeDataProjectionWriterSortingBlocksMicroseconds​

对数据块排序所花费的时间（对于 PROJECTION，其排序键可能与表的排序键不同）

MergeTreeDataProjectionWriterUncompressedBytes​

INSERT 到 MergeTree 表 PROJECTION 中的未压缩字节数（按列在内存中的存储形式计算）。

MergeTreeDataWriterBlocks​

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

MergeTreeDataWriterBlocksAlreadySorted​

INSERT 到 MergeTree 表中且看起来已经排好序的数据块数量。

MergeTreeDataWriterCompressedBytes​

向文件系统写入的字节数，用于 INSERT 到 MergeTree 表中的数据。

MergeTreeDataWriterMergingBlocksMicroseconds​

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

MergeTreeDataWriterProjectionsCalculationMicroseconds​

计算 PROJECTION 所耗费的时间

MergeTreeDataWriterRows​

INSERT 到 MergeTree 表的行数。

MergeTreeDataWriterSkipIndicesCalculationMicroseconds​

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

MergeTreeDataWriterSortingBlocksMicroseconds​

数据块排序耗时

MergeTreeDataWriterStatisticsCalculationMicroseconds​

计算统计信息所花费的时间

MergeTreeDataWriterUncompressedBytes​

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

MergeTreePrefetchedReadPoolInit​

在 MergeTreePrefetchedReadPool 中准备任务所耗费的时间

MergeTreeReadTaskRequestsReceived​

为选择读取任务（针对 MergeTree 表），远程服务器回调到发起方服务器的请求次数。在发起方服务器侧统计。

MergeTreeReadTaskRequestsSent​

远程服务器回调发起方服务器以选择读取任务（针对 MergeTree 表）时，请求的回调次数。在远程服务器端统计。

MergeTreeReadTaskRequestsSentElapsedMicroseconds​

远程服务器回调发起方服务器以选择读取任务（针对 MergeTree 表）所耗费的时间。在远程服务器端测量。

MergeVerticalStageExecuteMilliseconds​

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

MergeVerticalStageTotalMilliseconds​

后台合并垂直阶段耗费的总时间

MergeWrittenRows​

合并过程中写入的行数。

MergedColumns​

在合并的水平阶段合并的列数。

MergedIntoCompactParts​

合并成 Compact 格式的分区片段数量。

合并为 Wide 格式的分区片段数​

合并为 Wide 格式的分区片段数量。

MergedRows​

后台合并读取的行数。即合并前的行数。

MergedUncompressedBytes​

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

MergerMutatorPartsInRangesForMergeCount​

可供合并的候选分区片段数量

MergerMutatorPrepareRangesForMergeElapsedMicroseconds​

根据合并谓词准备可合并的分区片段范围的耗时。

MergerMutatorRangesForMergeCount​

候选合并范围的数量

MergerMutatorSelectPartsForMergeElapsedMicroseconds​

从可合并范围中选择分区片段的耗时。

MergerMutatorSelectRangePartsCount​

所选合并范围内的分区片段数量

MergerMutatorsGetPartsForMergeElapsedMicroseconds​

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

MergesRejectedByMemoryLimit​

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

MergesThrottlerBytes​

通过“max_merges_bandwidth_for_server”限流器的字节数。

MergesThrottlerSleepMicroseconds​

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

MergingSortedMilliseconds​

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

MetadataFromKeeperBackgroundCleanupBlobs​

后台任务清理空 blob 布局分区片段的次数

MetadataFromKeeperBackgroundCleanupErrors​

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

MetadataFromKeeperBackgroundCleanupObjects​

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

MetadataFromKeeperBackgroundCleanupTransactions​

后台任务清理旧 transaction 幂等性 token 的次数

MetadataFromKeeperCacheHit​

对象存储元数据请求直接由缓存返回、无需向 Keeper 发起请求的次数

MetadataFromKeeperCacheMiss​

对象存储元数据请求需要由 Keeper 响应的次数

MetadataFromKeeperCacheTooManyInvalidated​

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

MetadataFromKeeperCacheUpdateMicroseconds​

更新缓存（包括等待 Keeper 响应）耗费的总时间

MetadataFromKeeperCleanupTransactionCommit​

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

MetadataFromKeeperCleanupTransactionCommitRetry​

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

MetadataFromKeeperIndividualOperations​

单个或批量请求从 Keeper 读取或写入的路径数量

MetadataFromKeeperIndividualOperationsMicroseconds​

向 Keeper 发起单个或多个请求所花费的时间

MetadataFromKeeperOperations​

向 Keeper 发起请求的次数

MetadataFromKeeperReconnects​

重新连接 Keeper 的次数

MetadataFromKeeperTransactionCommit​

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

MetadataFromKeeperTransactionCommitRetry​

元数据 transaction 提交的重试次数

MetadataFromKeeperUpdateCacheOneLevel​

对目录树单个层级执行缓存更新的次数

MoveBackgroundExecutorTaskCancelMicroseconds​

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

MoveBackgroundExecutorTaskExecuteStepMicroseconds​

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

MoveBackgroundExecutorTaskResetMicroseconds​

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

MoveBackgroundExecutorWaitMicroseconds​

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

MutateTaskProjectionsCalculationMicroseconds​

在变更中计算 PROJECTION 所耗费的时间

MutatedRows​

为变更读取的行数。这是变更前的行数

MutatedUncompressedBytes​

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

MutationAffectedRowsUpperBound​

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

MutationAllPartColumns​

为分区片段中的所有列创建变更任务的次数

MutationCreatedEmptyParts​

被替换为空分区片段而非执行变更的分区片段总数

MutationExecuteMilliseconds​

执行变更所花费的总繁忙时间。

MutationSomePartColumns​

在分区片段中对某些列进行变更的任务创建次数

MutationTotalMilliseconds​

变更耗费的总时间。

MutationTotalParts​

系统尝试应用变更的分区片段总数

MutationUntouchedParts​

尝试对其应用变更，但根据谓词被完全跳过的分区片段总数

在所有读取任务中即时应用的变更​

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

MutationsThrottlerBytes​

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

MutationsThrottlerSleepMicroseconds​

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

NaiveBayesClassifierModelsAllocatedBytes​

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

NaiveBayesClassifierModelsLoaded​

已导入的朴素贝叶斯分类器模型数量。

NetworkReceiveBytes​

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

NetworkReceiveElapsedMicroseconds​

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

NetworkSendBytes​

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

NetworkSendElapsedMicroseconds​

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

NotCreatedLogEntryForMerge​

由于另一副本并发更新日志，未能创建用于合并 ReplicatedMergeTree 中分区片段的日志条目。

NotCreatedLogEntryForMutation​

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

OSCPUVirtualTimeMicroseconds​

操作系统视角下的 CPU 耗时。不包括因虚拟化导致的非自愿等待时间。

OSCPUWaitMicroseconds​

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

OSIOWaitMicroseconds​

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

OSReadBytes​

从磁盘或块设备读取的字节数。不包括从页缓存中读取的字节。由于数据块大小、预读等原因，可能包含超出实际需求的数据。

OSReadChars​

从文件系统读取的字节数，包括页缓存，以及网络和其他 File。

OSWriteBytes​

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

OSWriteChars​

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

ObjectStorageQueueCancelledFiles​

StorageS3(Azure)Queue 中已取消 File 的数量

ObjectStorageQueueCleanupMaxSetSizeOrTTLMicroseconds​

将 File 标记为失败状态所花费的时间

ObjectStorageQueueCommitRequests​

将 File 标记为失败或已处理状态的 Keeper 请求数

ObjectStorageQueueExceptionsDuringInsert​

S3(Azure)Queue 中执行 INSERT 时的异常数量

ObjectStorageQueueExceptionsDuringRead​

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

ObjectStorageQueueFailedFiles​

处理失败的 File 数量

ObjectStorageQueueFailedToBatchSetProcessing​

批量 Set 处理请求失败的次数

ObjectStorageQueueFilteredFiles​

StorageS3(Azure)Queue 中已筛选的 File 数量

ObjectStorageQueueInsertIterations​

插入操作的迭代次数

ObjectStorageQueueListedFiles​

StorageS3(Azure)Queue 中已列出 File 的数量

ObjectStorageQueueMovedObjects​

因 after_processing = move 而被移动的对象数量

ObjectStorageQueueProcessedFiles​

已处理的 File 数量

ObjectStorageQueueProcessedRows​

StorageS3(Azure)Queue 中已处理的行数

ObjectStorageQueuePullMicroseconds​

读取 File 数据耗费的时间

ObjectStorageQueueReadBytes​

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

ObjectStorageQueueReadFiles​

已读取的 File 数量（不等于实际 INSERT 的 File 数量）

ObjectStorageQueueReadRows​

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

ObjectStorageQueueRemovedObjects​

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

ObjectStorageQueueSuccessfulCommits​

Keeper 成功提交次数

ObjectStorageQueueTaggedObjects​

被标记为 after_processing = tag 的对象数量

ObjectStorageQueueTrySetProcessingFailed​

尝试将 File 设为处理中状态但未成功的次数

ObjectStorageQueueTrySetProcessingRequests​

尝试发起 Set processing 请求的次数

ObjectStorageQueueTrySetProcessingSucceeded​

成功将 File 设置为 processing 的次数

ObjectStorageQueueUnsuccessfulCommits​

Keeper 提交失败次数

ObsoleteReplicatedParts​

某个分区片段被从副本获取的另一个分区片段覆盖的次数 (即，我们已将被覆盖的分区片段标记为已过时且不再需要) 。

OpenedFileCacheHits​

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

OpenedFileCacheMicroseconds​

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

OpenedFileCacheMisses​

在已打开的文件缓存中未找到某个文件，因而不得不再次打开它的次数。

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​

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

ParallelReplicasAnnouncementMicroseconds​

发送通知所耗费的时间

ParallelReplicasAvailableCount​

可用于通过基于任务的并行副本执行查询的副本数量

ParallelReplicasCollectingOwnedSegmentsMicroseconds​

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

ParallelReplicasDeniedRequests​

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

ParallelReplicasHandleAnnouncementMicroseconds​

处理副本通告所耗费的时间

ParallelReplicasHandleRequestMicroseconds​

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

ParallelReplicasNumRequests​

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

ParallelReplicasProcessingPartsMicroseconds​

处理数据分区片段所耗费的时间

ParallelReplicasQueryCount​

查询执行过程中通过并行副本执行的 (子) 查询数量

ParallelReplicasReadAssignedForStealingMarks​

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

ParallelReplicasReadAssignedMarks​

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

ParallelReplicasReadMarks​

指定副本读取了多少个标记

ParallelReplicasReadRequestMicroseconds​

读取请求所耗费的时间

ParallelReplicasReadUnassignedMarks​

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

ParallelReplicasStealingByHashMicroseconds​

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

ParallelReplicasStealingLeftoversMicroseconds​

收集孤立分段所耗费的时间

并行副本不可用数量​

在使用基于任务的并行副本执行查询时，已选中但在查询执行过程中被发现不可用的副本数量

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 的总读取次数

ParquetPrunedRowGroups​

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

ParquetReadRowGroups​

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

ParquetRowsFilterExpression​

通过筛选的总行数

PartsLockHoldMicroseconds​

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

PartsLockWaitMicroseconds​

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

PartsLocks​

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

PatchesAcquireLockMicroseconds​

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

PatchesAcquireLockTries​

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

PatchesAppliedInAllReadTasks​

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

PatchesJoinAppliedInAllReadTasks​

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

PatchesJoinRowsAddedToHashTable​

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

PatchesMergeAppliedInAllReadTasks​

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

PatchesReadRows​

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

PatchesReadUncompressedBytes​

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

PerfAlignmentFaults​

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

PerfBranchInstructions​

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

PerfBranchMisses​

分支预测错误的指令数。

PerfBusCycles​

总线周期，可能与总周期数不同。

PerfCPUClock​

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

PerfCPUCycles​

总周期数。请注意 CPU 频率动态调整带来的影响。

PerfCPUMigrations​

进程迁移到其他 CPU 的次数

PerfCacheMisses​

缓存未命中。通常表示末级缓存（Last Level Cache）未命中；该指标通常与 PERFCOUNTHWCACHEREFERENCES 事件结合使用，以计算缓存未命中率。

PerfCacheReferences​

缓存访问。通常，这表示对末级缓存（Last Level Cache）的访问，但具体情况可能因 CPU 而异。其中可能包括预取和一致性消息；同样，这取决于 CPU 的设计。

PerfContextSwitches​

上下文切换次数

PerfDataTLBMisses​

数据 TLB 未命中次数

PerfDataTLBReferences​

数据 TLB 访问

PerfEmulationFaults​

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

PerfInstructionTLBMisses​

指令 TLB 未命中

PerfInstructionTLBReferences​

指令 TLB 访问

PerfInstructions​

已完成执行的指令数。请注意，这些可能会受到各种问题的影响，尤其是硬件中断次数。

PerfLocalMemoryMisses​

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

PerfLocalMemoryReferences​

本地 NUMA 节点内存读操作

PerfMinEnabledRunningTime​

启用时间最短的事件的运行时间。用于跟踪事件复用的数量

PerfMinEnabledTime​

对于所有事件，表示事件被启用的最短时间。用于跟踪事件多路复用的影响。

PerfRefCPUCycles​

总周期数；不受 CPU 频率调整影响。

PerfStalledCyclesBackend​

指令退休期间的停滞周期。

PerfStalledCyclesFrontend​

指令发射期间的停滞周期。

PerfTaskClock​

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

PolygonsAddedToPool​

已将一个多边形添加到 pointInPolygon 函数的缓存（池）中。

PolygonsInPoolAllocatedBytes​

添加到 pointInPolygon 函数的缓存（池）中的多边形所占用的字节数。

PreferredWarmedUnmergedParts​

请参见设置 prefer_warmed_unmerged_parts_seconds。读取查询使用缓存中已过时的预合并分区片段，而不是尚未被 CacheWarmer 预热到缓存中的合并后分区片段的次数。

PrimaryIndexCacheHits​

在主索引缓存中找到条目的次数，因此无需导入索引文件。

PrimaryIndexCacheMisses​

在主键索引缓存中未找到条目的次数，因此我们不得不将索引 File 加载到内存中，这是一个开销很大的操作，会增加查询延迟。

包含子查询的查询​

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

Query​

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

QueryBackupThrottlerBytes​

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

QueryBackupThrottlerSleepMicroseconds​

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

QueryCacheAgeSeconds​

已找到的查询缓存条目的年龄总和，以 Seconds 为单位。命中和未命中时都会设置该值。

QueryCacheHits​

在查询缓存中找到查询结果的次数（从而避免了查询计算）。仅对设置了 SETTING 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​

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

QueryPlanOptimizeMicroseconds​

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

查询被抢占​

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

QueryProfilerConcurrencyOverruns​

因其他线程中并发运行的查询分析器过多而放弃处理查询分析器信号的次数，这可能表明系统过载。

QueryProfilerErrors​

在异步栈展开期间发生的无效内存访问。

QueryProfilerRuns​

QueryProfiler 运行的次数。

QueryProfilerSignalOverruns​

因超限而放弃处理查询分析器信号的次数，加上操作系统因超限而未传递的信号次数。

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 而失败的 insert 数量。

QuorumParts​

以 quorum 方式写入的分区片段数。对于 sync insert，计为 1 个分区片段；对于会触发刷新 async inserts 的 insert，最多可能计为 async inserts 的数量。

QuorumWaitMicroseconds​

插入期间等待 quorum 所花费的总时间。

RWLockAcquiredReadLocks​

在重型 RWLock 中获取读锁的次数。

RWLockAcquiredWriteLocks​

在重型 RWLock 中获取到写锁的次数。

RWLockReadersWaitMilliseconds​

在重型 RWLock 中，等待获取读锁所耗费的总时间。

RWLockWritersWaitMilliseconds​

在重型 RWLock 中，等待获取写锁所花费的总时间。

ReadBackoff​

由于读取较慢而降低查询处理线程数量的次数。

ReadBufferFromAzureBytes​

从 Azure 读取的字节数。

ReadBufferFromAzureInitMicroseconds​

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

ReadBufferFromAzureMicroseconds​

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

ReadBufferFromAzureRequestsErrors​

从 Azure 读取期间发生的异常次数

ReadBufferFromFileDescriptorRead​

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

ReadBufferFromFileDescriptorReadBytes​

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

ReadBufferFromFileDescriptorReadFailed​

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

ReadBufferFromS3Bytes​

从 S3 读取的字节数。

ReadBufferFromS3InitMicroseconds​

初始化到 S3 的创建过程所花费的时间。

ReadBufferFromS3Microseconds​

从 S3 读取所耗费的时间。

ReadBufferFromS3RequestsErrors​

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

ReadBufferSeekCancelConnection​

导致创建新连接 (S3、HTTP) 的 seek 次数

ReadCompressedBytes​

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

ReadPatchesMicroseconds​

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

ReadTaskRequestsReceived​

远程服务器回调到发起方服务器以选择读取任务的请求次数（用于 s3Cluster 表函数及类似功能）。在发起方服务器端测量。

ReadTaskRequestsSent​

远程服务器为选择读取任务而回调发起方服务器的请求次数（用于 s3Cluster 表函数及类似功能）。该指标在远程服务器端统计。

ReadTaskRequestsSentElapsedMicroseconds​

远程服务器回调发起方服务器以选择读取任务所耗费的时间（用于 s3Cluster 表函数及类似场景）。在远程服务器端测量。

ReadTasksWithAppliedMutationsOnFly​

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

ReadTasksWithAppliedPatches​

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

ReadWriteBufferFromHTTPBytes​

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

ReadWriteBufferFromHTTPRequestsSent​

ReadWriteBufferFromHTTP 发送的 HTTP 请求数

RealTimeMicroseconds​

处理线程 (查询和其他任务) 消耗的总 (挂钟) 时间 (请注意，这是各线程时间的总和) 。

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 数据块时触发“Too many parts”异常而被拒绝的次数。

RejectedLightweightUpdates​

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

RejectedMutations​

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

RemoteFSBuffers​

用于从远程文件系统进行异步读取而创建的缓冲区数量

RemoteFSCancelledPrefetches​

因 seek 而取消的预取次数

RemoteFSLazySeeks​

延迟 seek 的次数

RemoteFSPrefetchedBytes​

预取缓冲区中的字节数

RemoteFSPrefetchedReads​

从预取缓冲区读取的次数

RemoteFSPrefetches​

从远程文件系统异步读取时执行的 prefetches 次数

RemoteFSSeeks​

异步缓冲区的 seek 总次数

RemoteFSSeeksWithReset​

导致创建新连接的 seek 操作次数

RemoteFSUnprefetchedBytes​

未预取缓冲区中的字节数

RemoteFSUnprefetchedReads​

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

RemoteFSUnusedPrefetches​

缓冲区销毁时仍处于待处理状态的 prefetches 数量

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​

由于 ZooKeeper 中的 session 过期，Replicated 表需要取消初始化其状态的次数。每当 ZooKeeper 再次可用时，该状态都会重新初始化。

ReplicatedCoveredPartsInZooKeeperOnStart​

用于调试。指 ZooKeeper 中存在且已被覆盖分区片段覆盖、但磁盘上不存在的分区片段数量。在服务器启动时检查。

ReplicatedDataLoss​

所需的数据分区片段在任何副本上都不存在的次数 (包括当前离线的副本) 。这些数据分区片段可以确定已丢失。由于复制是异步的，这种情况是正常现象 (如果未启用 quorum insert) ：当写入该数据分区片段的副本发生故障，并且该副本在故障后重新上线时，它将不包含该数据分区片段。

ReplicatedPartChecks​

我们不得不在副本上对数据分区片段执行高级搜索，或确认现有数据分区片段是否确有必要存在的次数。

ReplicatedPartChecksFailed​

在副本上对某个分区片段执行高级搜索但未得到结果，或发现了意外的分区片段并将其移到别处的次数。

ReplicatedPartFailedFetches​

从 ReplicatedMergeTree 表副本下载数据分区片段失败的次数。

ReplicatedPartFetches​

从 ReplicatedMergeTree 表的副本中下载数据分区片段的次数。

ReplicatedPartFetchesOfMerged​

优先从 ReplicatedMergeTree 表的副本下载已合并的分区片段、而不是自行执行合并的次数 (通常为了节省网络流量，我们更倾向于自行合并) 。当缺少执行合并所需的全部源分区片段，或者该数据分区片段已经足够旧时，就会出现这种情况。

ReplicatedPartMerges​

ReplicatedMergeTree 表中分区片段成功合并的次数。

ReplicatedPartMutations​

ReplicatedMergeTree 表的分区片段成功执行变更的次数。

恢复分区片段时跳过的字节数​

恢复分区片段时被跳过的文件总大小

RestorePartsSkippedFiles​

恢复分区片段时跳过的文件数量

主读取器读取的行数​

主读取器从 MergeTree 表中读取的行数 (在 PREWHERE 步骤之后) 。

RowsReadByPrewhereReaders​

prewhere 读取器从 MergeTree 表中总共读取的行数。

RuntimeDataflowStatisticsInputBytes​

收集到的统计信息，表示如果查询以并行副本方式执行，各副本将读取的字节数

RuntimeDataflowStatisticsOutputBytes​

收集的统计信息：如果以并行副本方式执行查询，副本将发送给发起节点的字节数

RuntimeFilterBlocksProcessed​

JOIN 运行时过滤器处理的数据块数量

RuntimeFilterBlocksSkipped​

因过滤比例不佳而被动态禁用时，JOIN 运行时过滤器在未处理情况下跳过的数据块数量

RuntimeFilterRowsChecked​

JOIN 运行时过滤器检查的行数

RuntimeFilterRowsPassed​

通过 JOIN 运行时过滤器且未被过滤掉的行数

RuntimeFilterRowsSkipped​

被 JOIN 运行时过滤器跳过的数据块中的行数

RuntimeFiltersCreated​

在一次查询中创建的不同 JOIN 运行时过滤器数量

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​

将 File 设置为失败所花费的时间

S3QueueSetFileProcessedMicroseconds​

将 File 设置为已处理所花费的时间

S3QueueSetFileProcessingMicroseconds​

将 File 设置为处理中所花费的时间

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 缓存中找到请求源的次数

SchemaInferenceCacheInvalidations​

由于数据变化导致缓存中的 schema 失效的次数

SchemaInferenceCacheMisses​

请求的源不在 schema 缓存中的次数

SchemaInferenceCacheNumRowsHits​

从文件进行计数时，在 schema 缓存中命中行数的次数

SchemaInferenceCacheNumRowsMisses​

从文件进行计数时，请求的源在缓存中，但行数不在缓存中的次数

SchemaInferenceCacheSchemaHits​

在 schema 推断期间，在 schema 缓存中命中 schema 的次数

SchemaInferenceCacheSchemaMisses​

在 schema 推断期间，请求的源在缓存中，但 schema 不在缓存中的次数

Seek​

调用 lseek 函数的次数。

使用主键的 SELECT 查询​

统计使用主键来判断 WHERE 条件的 SELECT 查询数量

SelectQueriesWithSubqueries​

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

SelectQuery​

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

SelectQueryTimeMicroseconds​

SELECT 查询的总耗时。

SelectedBytes​

从所有表中 SELECT 的字节数 (未压缩；对于列，按其在内存中的存储形式计算) 。

SelectedMarks​

从 MergeTree 表中选定要读取的标记（索引粒度）数量。

SelectedMarksTotal​

在选择从 MergeTree 表中读取哪些标记之前的标记总数 (索引粒度块) 。

SelectedParts​

从 MergeTree 表中选定读取的分区片段数量。

SelectedPartsTotal​

从 MergeTree 表中选择要读取哪些分区片段之前的分区片段总数。

SelectedRanges​

从 MergeTree 表中选定要读取的所有数据分区片段里，非相邻区间的数量。

SelectedRows​

从所有表中通过 SELECT 查询的行数。

SelfDuplicatedAsyncInserts​

向 ReplicatedMergeTree 表执行 INSERT 时，插入数据块中被自动去重的异步插入数量。

ServerStartupMilliseconds​

从服务器启动到开始监听套接字所经过的时间，以 Milliseconds 为单位

SharedDatabaseCatalogFailedToApplyState​

在 SharedDatabaseCatalog 中应用新状态失败的次数

SharedDatabaseCatalogStateApplicationMicroseconds​

在 SharedDatabaseCatalog 中应用新状态的总耗时

SharedMergeTreeCondemnedPartsKillRequest​

移除已判定为废弃的分区片段使用了多少个 ZooKeeper 请求

SharedMergeTreeCondemnedPartsLockConflict​

因冲突导致获取锁失败的次数

SharedMergeTreeCondemnedPartsRemoved​

已移除的废弃分区片段数量

SharedMergeTreeDataPartsFetchAttempt​

尝试获取分区片段的次数

SharedMergeTreeDataPartsFetchFromPeer​

从对等节点获取数据分区片段的次数

SharedMergeTreeDataPartsFetchFromPeerMicroseconds​

从对等节点获取数据分区片段所用的微秒数

SharedMergeTreeDataPartsFetchFromS3​

从 S3 获取数据分区片段的次数

SharedMergeTreeHandleBlockingParts​

scheduleDataProcessingJob 中要处理的阻塞分区片段数

SharedMergeTreeHandleBlockingPartsMicroseconds​

在 scheduleDataProcessingJob 中处理阻塞分区片段所耗费的时间

SharedMergeTreeHandleFetchPartsMicroseconds​

在 scheduleDataProcessingJob 中处理已获取分区片段所用的时间

SharedMergeTreeHandleOutdatedParts​

在 scheduleDataProcessingJob 中处理的过期分区片段数量

SharedMergeTreeHandleOutdatedPartsMicroseconds​

在 scheduleDataProcessingJob 中处理过期分区片段所耗的时间

SharedMergeTreeLoadChecksumAndIndexesMicroseconds​

仅针对 SharedMergeTree 的 loadColumnsChecksumsIndexes 耗时

SharedMergeTreeMergeMutationAssignmentAttempt​

尝试分配合并或变更任务的次数

SharedMergeTreeMergeMutationAssignmentFailedWithConflict​

因 Keeper 中发生冲突而导致分配合并或变更失败的次数

SharedMergeTreeMergeMutationAssignmentFailedWithNothingToDo​

尝试分配合并或变更任务时，因无可合并内容而失败的次数

SharedMergeTreeMergeMutationAssignmentSuccessful​

尝试分配合并或变更任务的次数

SharedMergeTreeMergePartsMovedToCondemned​

移入 condemned 目录的分区片段数量

SharedMergeTreeMergePartsMovedToOudated​

被移动到 oudated 目录的分区片段数量

SharedMergeTreeMergeSelectingTaskMicroseconds​

SMT 的合并选择任务耗时 (微秒)

SharedMergeTreeMetadataCacheHintLoadedFromCache​

无需访问 Keeper 即找到元数据缓存提示的次数

SharedMergeTreeOptimizeAsync​

异步执行的 OPTIMIZE 查询

SharedMergeTreeOptimizeSync​

已执行的同步 OPTIMIZE 查询

SharedMergeTreeOutdatedPartsConfirmationInvocations​

确认过期分区片段的调用次数

SharedMergeTreeOutdatedPartsConfirmationRequest​

用于配置过期分区片段的 ZooKeeper 请求次数

SharedMergeTreeOutdatedPartsHTTPRequest​

为确认过期分区片段而发送了多少个 HTTP 请求

SharedMergeTreeOutdatedPartsHTTPResponse​

为确认过期分区片段而发送的 HTTP 响应数量

SharedMergeTreePartsKillerMicroseconds​

分区片段清理器主线程耗时多久

SharedMergeTreePartsKillerParts​

清理器已计划处理的分区片段数量

SharedMergeTreePartsKillerPartsMicroseconds​

移除分区片段耗时多少 (由多个线程数量执行)

SharedMergeTreePartsKillerRuns​

分区片段清理器运行的次数

SharedMergeTreeReplicaSetUpdatesFromZooKeeper​

从 ZooKeeper 更新副本集的次数

SharedMergeTreeReplicaSetUpdatesFromZooKeeperMicroseconds​

更新副本集所花费的时间

SharedMergeTreeReplicaSetUpdatesFromZooKeeperRequests​

为更新副本集而发起的 ZooKeeper 请求总次数

SharedMergeTreeScheduleDataProcessingJob​

scheduleDataProcessingJob 调用次数/

SharedMergeTreeScheduleDataProcessingJobMicroseconds​

scheduleDataProcessingJob 的执行时间

SharedMergeTreeScheduleDataProcessingJobNothingToScheduled​

scheduleDataProcessingJob 被调用但无需处理任何任务的次数

SharedMergeTreeSelectPartsForCoordinatedFetchMicroseconds​

selectPartsForCoordinatedFetch 的耗时

SharedMergeTreeSelectPartsForCoordinatedFetchParts​

由 selectPartsForCoordinatedFetch 选取的分区片段数量

SharedMergeTreeSelectPartsForFullFetchMicroseconds​

selectPartsForFullFetch 的耗时

SharedMergeTreeSelectPartsForFullFetchParts​

selectPartsForFullFetch 选中的分区片段数

SharedMergeTreeSelectPartsForRendezvousFetchMicroseconds​

selectPartsForRendezvousFetch 的耗时

SharedMergeTreeSelectPartsForRendezvousFetchParts​

由 selectPartsForRendezvousFetch 选中的分区片段数量

SharedMergeTreeSnapshotPartsCleanRequest​

SnapshotCleanerThread 判定需要清理分区片段的次数

SharedMergeTreeSnapshotPartsCleanerMicroseconds​

SnapshotCleanerThread 的运行时长

SharedMergeTreeSnapshotPartsCleanerParts​

SnapshotCleanerThread 尝试清理一个分区片段所用的时间

SharedMergeTreeSnapshotPartsCleanerPartsMicroseconds​

SnapshotCleanerThread 清理分区片段的耗时

SharedMergeTreeSnapshotPartsCleanerRuns​

SnapshotCleanerThread 的运行次数

SharedMergeTreeSnapshotPartsRemoved​

SnapshotCleanerThread 成功清理分区片段的次数

SharedMergeTreeTryUpdateDiskMetadataCacheForPartMicroseconds​

在 scheduleDataProcessingJob 中执行 tryUpdateDiskMetadataCacheForPart 的耗时

SharedMergeTreeVirtualPartsUpdateMicroseconds​

虚拟分区片段更新时间 (微秒)

SharedMergeTreeVirtualPartsUpdates​

虚拟分区片段更新次数

SharedMergeTreeVirtualPartsUpdatesByLeader​

leader 的虚拟分区片段更新

SharedMergeTreeVirtualPartsUpdatesForMergesOrStatus​

由非默认后台作业发起的虚拟分区片段更新

SharedMergeTreeVirtualPartsUpdatesFromPeer​

来自对等节点的虚拟分区片段更新次数

SharedMergeTreeVirtualPartsUpdatesFromPeerMicroseconds​

来自对等节点的虚拟分区片段更新 (微秒)

SharedMergeTreeVirtualPartsUpdatesFromZooKeeper​

来自 ZooKeeper 的虚拟分区片段更新次数

SharedMergeTreeVirtualPartsUpdatesFromZooKeeperMicroseconds​

来自 ZooKeeper 的虚拟分区片段更新时间 (微秒)

SharedMergeTreeVirtualPartsUpdatesLeaderFailedElection​

虚拟分区片段更新的 leader 选举失败

SharedMergeTreeVirtualPartsUpdatesLeaderSuccessfulElection​

虚拟分区片段更新 leader 选举成功

SharedMergeTreeVirtualPartsUpdatesPeerNotFound​

来自对等节点的虚拟更新失败，因为未找到任何对等节点

SharedPartsLockHoldMicroseconds​

在 MergeTree 表中持有共享数据分区片段锁的总时间

SharedPartsLockWaitMicroseconds​

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

SharedPartsLocks​

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

SleepFunctionCalls​

sleep 函数 (sleep、sleepEachRow) 的调用次数。

SleepFunctionElapsedMicroseconds​

在睡眠函数 (sleep、sleepEachRow) 中休眠所用的时间。

SleepFunctionMicroseconds​

睡眠函数 (sleep、sleepEachRow) 中设置的休眠时长。

SlowRead​

文件读取中较慢的读取次数。这表示系统过载。阈值由 read_backoff_* settings 控制。

软缺页故障​

查询执行线程中的软缺页故障数量。软缺页故障通常表示内存分配器缓存未命中，因此需要操作系统创建新的内存映射，并随后分配一个物理内存页。

StorageBufferErrorOnFlush​

由于向目标表写入时发生错误，'Buffer' 表中的缓冲区无法刷新的次数。

StorageBufferFlush​

‘Buffer’ 表中缓冲区刷新的次数。

StorageBufferLayerLockReadersWaitMilliseconds​

读取时等待 Buffer 层的时间。

StorageBufferLayerLockWritersWaitMilliseconds​

等待可写入的空闲 Buffer 层的时间 (可用于调优 Buffer 层) 。

StorageBufferPassedAllMinThresholds​

在“Buffer”表中，为刷新缓冲区而达到最小阈值条件的次数。

StorageBufferPassedBytesFlushThreshold​

在 'Buffer' 表中，因达到仅后台按字节数触发的刷新阈值而刷新缓冲区的次数。这是一项仅供专家使用的指标。如果你看到这里却并非专家，请停止阅读。

StorageBufferPassedBytesMaxThreshold​

在 'Buffer' 表中，为刷新缓冲区而达到最大字节数阈值条件的次数。

StorageBufferPassedRowsFlushThreshold​

在 'Buffer' 表中，为刷新缓冲区而达到仅后台刷新的行数阈值的次数。这是一项仅供专家使用的指标。如果你读到了这里，而你不是专家，请停止阅读。

StorageBufferPassedRowsMaxThreshold​

在 'Buffer' 表中，因达到最大行数阈值而触发缓冲区刷新的次数。

StorageBufferPassedTimeFlushThreshold​

在 Buffer 表中，由于达到仅后台刷新的时间阈值而触发缓冲区刷新的次数。这是仅供专家使用的指标。如果你读到这里且并非专家，请停止阅读。

StorageBufferPassedTimeMaxThreshold​

在 Buffer 表中，因达到最大时间阈值条件而触发缓冲区刷新的次数。

StorageConnectionsCreated​

存储创建的连接数

StorageConnectionsElapsedMicroseconds​

为存储创建连接的总耗时

StorageConnectionsErrors​

存储连接创建失败的次数

StorageConnectionsExpired​

存储的过期连接数

StorageConnectionsPreserved​

为存储保留的连接数

StorageConnectionsReset​

存储连接重置数

StorageConnectionsReused​

存储的复用连接数

SummingSortedMilliseconds​

对已排序列求和所花费的总时间

SuspendSendingQueryToShard​

启用 async_query_sending_for_remote 时，向分片发送查询被暂停的总次数。

同步读取等待微秒数​

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

SynchronousRemoteReadWaitMicroseconds​

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

SystemLogErrorOnFlush​

任一系统日志刷新到对应的 system table 失败的次数。刷新失败后会重复尝试。

SystemTimeMicroseconds​

处理过程中 (包括查询和其他任务) ，线程在操作系统内核模式下执行 CPU 指令所花费的总时间。这部分时间指耗费在系统调用上的时间，不包括阻塞式系统调用期间的等待时间。

TableFunctionExecute​

表函数的调用次数。

TextIndexDiscardHint​

将直接从文本索引读取作为提示加入、但因选择性过低而被丢弃的索引粒度块数量。

TextIndexHeaderCacheHits​

头部在缓存中命中的次数。

TextIndexHeaderCacheMisses​

头部未在缓存中命中的次数。

TextIndexPostingsCacheHits​

文本索引倒排列表在缓存中命中的次数。

TextIndexPostingsCacheMisses​

文本索引倒排列表在缓存中未命中的次数。

TextIndexReadDictionaryBlocks​

从磁盘读取文本索引字典数据块的次数。

TextIndexReadGranulesMicroseconds​

读取和分析文本索引粒度块的总耗时。

TextIndexReadPostings​

从文本索引读取倒排列表的次数。

TextIndexReadSparseIndexBlocks​

从文本索引读取稀疏索引数据块的次数。

TextIndexReaderTotalMicroseconds​

读取文本索引耗费的总时间。

TextIndexTokensCacheHits​

在缓存中命中文本索引 token 信息的次数。

TextIndexTokensCacheMisses​

文本索引 token 信息在缓存中未命中的次数。

TextIndexUseHint​

已添加文本索引直接读取提示且实际使用了该提示的索引粒度块数量。

TextIndexUsedEmbeddedPostings​

使用字典中嵌入的倒排列表的次数。

ThreadPoolReaderPageCacheHit​

ThreadPoolReader 中从页缓存完成读取的次数。

ThreadPoolReaderPageCacheHitBytes​

在 ThreadPoolReader 中从页缓存读取的数据字节数。

ThreadPoolReaderPageCacheHitElapsedMicroseconds​

在 ThreadPoolReader 中从页缓存读取数据所花费的时间。

ThreadPoolReaderPageCacheMiss​

ThreadPoolReader 中未从页缓存读取、而是移交给线程池处理的次数。

ThreadPoolReaderPageCacheMissBytes​

在 ThreadPoolReader 中读取、且未从页缓存读取而转交给线程池处理的字节数。

ThreadPoolReaderPageCacheMissElapsedMicroseconds​

在 ThreadPoolReader 中，异步作业读取数据所耗费的时间——即未从页缓存读取时的耗时。

ThreadpoolReaderPrepareMicroseconds​

用于准备操作的耗时 (例如调用 reader 的 seek() 方法)

ThreadpoolReaderReadBytes​

异步读取期间从线程池任务中读取的字节数

ThreadpoolReaderSubmit​

异步读取时线程池任务读取的字节数

ThreadpoolReaderSubmitLookupInCacheMicroseconds​

用于检查内容是否已缓存所花费的时间

ThreadpoolReaderSubmitReadSynchronously​

未在线程池中调度任务、而是改为同步读取的次数

ThreadpoolReaderSubmitReadSynchronouslyBytes​

同步读取的字节数

ThreadpoolReaderSubmitReadSynchronouslyMicroseconds​

同步读取耗时多少

ThreadpoolReaderTaskMicroseconds​

异步读取过程中获取数据所花费的时间

ThrottlerSleepMicroseconds​

查询为遵循所有限流设置而休眠的总时长。

TinyS3Clients​

复用另一客户端现有身份验证提供程序的 S3 客户端副本数量。

USearchAddComputedDistances​

向 USearch 索引添加向量时，计算距离的次数。

USearchAddCount​

已添加到 usearch 索引的向量数。

USearchAddVisitedMembers​

向 usearch 索引中添加向量时访问的节点数量。

USearchSearchComputedDistances​

在搜索 usearch 索引时计算距离的次数。

USearchSearchCount​

在 usearch 索引上执行的搜索操作次数。

USearchSearchVisitedMembers​

在 usearch 索引中搜索时访问的节点数量。

UncompressedCacheHits​

在未压缩缓存中命中数据块的次数 (从而避免解压缩) 。

UncompressedCacheMisses​

数据块未在未压缩缓存中命中的次数 (因此需要进行解压缩) 。

UncompressedCacheWeightLost​

从未压缩缓存中逐出的字节数。

UserTimeMicroseconds​

处理（查询和其他任务）过程中，线程在用户态执行 CPU 指令所花费的总时间。这包括因访问主内存、缓存未命中、分支预测错误、超线程等导致 CPU 流水线停滞的时间。

VectorSimilarityIndexCacheHits​

索引粒度块在向量索引缓存中命中的次数。

VectorSimilarityIndexCacheMisses​

索引粒度块在向量索引缓存中未命中、必须从磁盘读取的次数。

VectorSimilarityIndexCacheWeightLost​

从向量索引缓存中被逐出的字节数估计值。

VersionedCollapsingSortedMilliseconds​

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

WaitMarksLoadMicroseconds​

加载标记所花费的时间

WaitPrefetchTaskMicroseconds​

等待 prefetch 读取器所花费的时间

WasmDeserializationMicroseconds​

执行 WebAssembly 代码所用的时间

WasmGuestExecuteMicroseconds​

执行 WebAssembly 代码所用的时间

WasmMemoryAllocated​

为 WebAssembly 隔离区分配的内存总量

WasmModuleInstatiate​

已创建的 WebAssembly 隔离环境数量

WasmSerializationMicroseconds​

执行 WebAssembly 代码所用的时间

WasmTotalExecuteMicroseconds​

执行 WebAssembly 代码所用的时间

WriteBufferFromFileDescriptorWrite​

对 File 描述符的写入（write/pwrite）次数。不包括套接字。

WriteBufferFromFileDescriptorWriteBytes​

写入 File 描述符的字节数。如果 File 已压缩，此处将显示压缩后的数据大小。

WriteBufferFromFileDescriptorWriteFailed​

对 File 描述符执行写入（write/pwrite）操作失败的次数。

WriteBufferFromHTTPBytes​

由 WriteBufferFromHTTP 接收和发送的有效负载字节总量。不包括 HTTP 头。

WriteBufferFromHTTPRequestsSent​

由 WriteBufferFromHTTP 发送的 HTTP 请求数量

WriteBufferFromS3Bytes​

写入 S3 的字节数。

WriteBufferFromS3Microseconds​

向 S3 写入所花费的时间。

WriteBufferFromS3RequestsErrors​

写入 S3 时发生的异常次数。

WriteBufferFromS3WaitInflightLimitMicroseconds​

当当前请求数量达到 s3_max_inflight_parts_for_one_file 定义的 limit 时，等待其中部分请求完成所花费的时间。

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) 请求数。

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 请求数量。此类请求通常很少需要，也很少会被使用。

ZooKeeper事务​

ZooKeeper 操作次数，包括读操作、写操作以及多重事务。

ZooKeeperUserExceptions​

处理与数据相关的 ZooKeeper 操作时发生的异常次数 (如节点不存在、版本错误或类似情况) 。

ZooKeeperWaitMicroseconds​

创建请求后等待 ZooKeeper 响应所耗费的微秒数，按所有发起请求的线程累计。

ZooKeeperWatchResponse​

从 ZooKeeper 收到监视通知的次数。

另请参阅