# Amazon Aurora PostgreSQL 参考
在以下主题中，可以找到有关 Amazon Aurora PostgreSQL 中的排序规则、函数、参数和等待事件的信息。
**Topics**
+ [用于 EBCDIC 和其他大型机迁移的 Aurora PostgreSQL 排序规则](#AuroraPostgreSQL.Reference.Collations.mainframe.migration)
+ [Aurora PostgreSQL 中支持的排序规则](PostgreSQL-Collations.md)
+ [Aurora PostgreSQL 函数参考](Appendix.AuroraPostgreSQL.Functions.md)
+ [Amazon Aurora PostgreSQL 参数](AuroraPostgreSQL.Reference.ParameterGroups.md)
+ [Amazon Aurora PostgreSQL 等待事件](AuroraPostgreSQL.Reference.Waitevents.md)
## 用于 EBCDIC 和其他大型机迁移的 Aurora PostgreSQL 排序规则
将大型机应用程序迁移到新平台（如 AWS）可以完美地保留应用程序行为。要使应用程序在新平台上的行为与在大型机上的行为完全相同，需要使用相同的排序规则对迁移的数据进行整理。例如，许多 Db2 迁移解决方案将空值转移到 u0180（Unicode 位置 0180），因此这些排序规则首先对 u0180 进行排序。这是一个示例，说明排序规则与其大型机来源有何不同，以及为什么需要选择能够更好地映射到原始 EBCDIC 排序规则的排序规则。
Aurora PostgreSQL 14.3 及更高版本提供了许多 ICU 和 EBCDIC 排序规则，以支持使用 AWS Mainframe Modernization 服务向 AWS 执行此类迁移。要了解有关此服务的更多信息，请参阅[什么是 AWS Mainframe Modernization？](https://docs.aws.amazon.com/m2/latest/userguide/what-is-m2.html)
在下表中，您可以找到 Aurora PostgreSQL 提供的排序规则。这些排序规则遵循 EBCDIC 规则，并确保大型机应用程序在 AWS 上的运行方式与在大型机环境中相同。排序规则名称包括相关的代码页（cp*nnnn*），以便您可以为大型机来源选择适当的排序规则。例如，使用 `en-US-cp037-x-icu` 针对 EBCDIC 数据（源自使用代码页 037 的大型机应用程序的）实现排序规则行为。
| EBCDIC 排序规则 | AWS Blu Age 排序规则 | AWS Micro Focus 排序规则 |
| --- | --- | --- |
| da-DK-cp1142-x-icu | da-DK-cp1142b-x-icu | da-DK-cp1142m-x-icu |
| da-DK-cp277-x-icu | da-DK-cp277b-x-icu | – |
| de-DE-cp1141-x-icu | de-DE-cp1141b-x-icu | de-DE-cp1141m-x-icu |
| de-DE-cp273-x-icu | de-DE-cp273b-x-icu | – |
| en-GB-cp1146-x-icu | en-GB-cp1146b-x-icu | en-GB-cp1146m-x-icu |
| en-GB-cp285-x-icu | en-GB-cp285b-x-icu | – |
| en-US-cp037-x-icu | en-US-cp037b-x-icu | – |
| en-US-cp1140-x-icu | en-US-cp1140b-x-icu | en-US-cp1140m-x-icu |
| es-ES-cp1145-x-icu | es-ES-cp1145b-x-icu | es-ES-cp1145m-x-icu |
| es-ES-cp284-x-icu | es-ES-cp284b-x-icu | – |
| fi-FI-cp1143-x-icu | fi-FI-cp1143b-x-icu | fi-FI-cp1143m-x-icu |
| fi-FI-cp278-x-icu | fi-FI-cp278b-x-icu | – |
| fr-FR-cp1147-x-icu | fr-FR-cp1147b-x-icu | fr-FR-cp1147m-x-icu |
| fr-FR-cp297-x-icu | fr-FR-cp297b-x-icu | – |
| it-IT-cp1144-x-icu | it-IT-cp1144b-x-icu | it-IT-cp1144m-x-icu |
| it-IT-cp280-x-icu | it-IT-cp280b-x-icu | – |
| nl-BE-cp1148-x-icu | nl-BE-cp1148b-x-icu | nl-BE-cp1148m-x-icu |
| nl-BE-cp500-x-icu | nl-BE-cp500b-x-icu | – |
要了解有关 AWS Blu Age 的更多信息，请参阅《AWS Mainframe Modernization 用户指南》中的[教程：AWS Blu Age 的托管式运行时](https://docs.aws.amazon.com/m2/latest/userguide/tutorial-runtime-ba.html)。
有关使用 AWS Micro Focus 的更多信息，请参阅《AWS Mainframe Modernization 用户指南》中的[教程：Micro Focus 的托管式运行时](https://docs.aws.amazon.com/m2/latest/userguide/tutorial-runtime.html)。
有关在 PostgreSQL 中管理排序规则的更多信息，请参阅 PostgreSQL 文档中的[排序规则支持](https://www.postgresql.org/docs/current/collation.html)。
# Aurora PostgreSQL 中支持的排序规则
排序规则是一组规则，用于确定如何对存储在数据库中的字符串进行排序和比较。排序规则在计算机系统中起着重要作用，并作为操作系统的一部分包含在其中。当向语言中添加新字符或排序规则发生变化时，排序规则会随着时间的推移而变化。
排序规则库为排序规则定义特定的规则和算法。PostgreSQL 中最常用的排序规则库是 GNU C（Glibc）和 Unicode 国际化组件（ICU）。原定设置情况下，Aurora PostgreSQL 使用 Glibc 排序规则，其中包括适用于多字节字符序列的 Unicode 字符排序顺序。
当您创建新的 Aurora PostgreSQL 数据库集群时，它将检查操作系统中是否有可用的排序规则。`CREATE DATABASE` 命令的 PostgreSQL 参数 `LC_COLLATE` 和 `LC_CTYPE` 用于指定排序规则，该排序规则是该数据库中的原定设置排序规则。或者，您也可以在 `CREATE DATABASE` 中使用 `LOCALE` 参数来设置这些参数。这决定了数据库中字符串的原定设置排序规则以及将字符分类为字母、数字或符号的规则。您也可以选择用于列、索引或查询的排序规则。
Aurora PostgreSQL 依赖于操作系统中的 Glibc 库来提供排序规则支持。Aurora PostgreSQL 实例定期使用最新版本的操作系统进行更新。这些更新有时包含较新版本的 Glibc 库。较新版本的 Glibc 很少会更改某些字符的排序顺序或排序规则，这可能会导致数据的排序方式不同或生成无效的索引条目。如果您在更新期间发现用于排序规则的排序顺序有问题，则可能需要重建索引。
为了减少 Glibc 更新可能产生的影响，Aurora PostgreSQL 现在包含一个独立的原定设置排序规则库。这个排序规则库在 Aurora PostgreSQL 14.6、13.9、12.13、11.18 和更高的次要版本中可用。它与 Glibc 2.26-59.amzn2 兼容，并提供排序顺序稳定性以防止错误的查询结果。
# Aurora PostgreSQL 函数参考
下面，您可以找到适用于运行 Aurora PostgreSQL 兼容版数据库引擎的 Aurora 数据库集群的 Aurora PostgreSQL 函数的列表。这些 Aurora PostgreSQL 函数是标准 PostgreSQL 函数的补充。有关标准 PostgreSQL 函数的更多信息，请参阅 [PostgreSQL–函数和运算符](https://www.postgresql.org/docs/current/functions.html)。
## 概述
您可以为运行 Aurora PostgreSQL 的 Amazon RDS 数据库实例使用以下函数：
+ [aurora\$1db\$1instance\$1identifier](aurora_db_instance_identifier.md)
+ [aurora\$1ccm\$1status](aurora_ccm_status.md)
+ [aurora\$1global\$1db\$1instance\$1status](aurora_global_db_instance_status.md)
+ [aurora\$1global\$1db\$1status](aurora_global_db_status.md)
+ [aurora\$1list\$1builtins](aurora_list_builtins.md)
+ [aurora\$1replica\$1status](aurora_replica_status.md)
+ [aurora\$1stat\$1activity](aurora_stat_activity.md)
+ [aurora\$1stat\$1backend\$1wait](aurora_stat_backend_waits.md)
+ [aurora\$1stat\$1bgwriter](aurora_stat_bgwriter.md)
+ [aurora\$1stat\$1database](aurora_stat_database.md)
+ [aurora\$1stat\$1dml\$1activity](aurora_stat_dml_activity.md)
+ [aurora\$1stat\$1get\$1db\$1commit\$1latency](aurora_stat_get_db_commit_latency.md)
+ [aurora\$1stat\$1logical\$1wal\$1cache](aurora_stat_logical_wal_cache.md)
+ [aurora\$1stat\$1memctx\$1usage](aurora_stat_memctx_usage.md)
+ [aurora\$1stat\$1optimized\$1reads\$1cache](aurora_stat_optimized_reads_cache.md)
+ [aurora\$1stat\$1plans](aurora_stat_plans.md)
+ [aurora\$1stat\$1reset\$1wal\$1cache](aurora_stat_reset_wal_cache.md)
+ [aurora\$1stat\$1statements](aurora_stat_statements.md)
+ [aurora\$1stat\$1system\$1waits](aurora_stat_system_waits.md)
+ [aurora\$1stat\$1wait\$1event](aurora_stat_wait_event.md)
+ [aurora\$1stat\$1wait\$1type](aurora_stat_wait_type.md)
+ [aurora\$1version](aurora_version.md)
+ [aurora\$1volume\$1logical\$1start\$1lsn](aurora_volume_logical_start_lsn.md)
+ [aurora\$1wait\$1report](aurora_wait_report.md)
# aurora\$1db\$1instance\$1identifier
报告您所连接的数据库实例的名称。
## 语法
```
aurora_db_instance_identifier()
```
## 参数
无
## 返回类型
VARCHAR 字符串
## 使用说明
此函数显示数据库客户端或应用程序连接的 Aurora PostgreSQL 兼容版集群的数据库实例名称。
此函数从 Aurora PostgreSQL 版本 13.7、12.11、11.16、10.21 以及所有其他更高版本开始提供。
## 示例
以下示例显示了调用 `aurora_db_instance_identifier` 函数的结果。
```
=> SELECT aurora_db_instance_identifier();
aurora_db_instance_identifier
-------------------------------
test-my-instance-name
```
您可以将此函数的结果与 `aurora_replica_status` 函数相结合，以获得有关连接的数据库实例的详细信息。[aurora\$1replica\$1status](aurora_replica_status.md) 本身并不能显示您正在使用哪个数据库实例。下面的示例演示如何操作。
```
=> SELECT *
FROM aurora_replica_status() rt,
aurora_db_instance_identifier() di
WHERE rt.server_id = di;
-[ RECORD 1 ]----------------------+-----------------------
server_id | test-my-instance-name
session_id | MASTER_SESSION_ID
durable_lsn | 88492069
highest_lsn_rcvd |
current_read_lsn |
cur_replay_latency_in_usec |
active_txns |
is_current | t
last_transport_error | 0
last_error_timestamp |
last_update_timestamp | 2022-06-03 11:18:25+00
feedback_xmin |
feedback_epoch |
replica_lag_in_msec |
log_stream_speed_in_kib_per_second | 0
log_buffer_sequence_number | 0
oldest_read_view_trx_id |
oldest_read_view_lsn |
pending_read_ios | 819
```
# aurora\$1ccm\$1status
显示集群缓存管理器的状态。
## 语法
```
aurora_ccm_status()
```
## 参数
无。
## 返回类型
包含以下列的 SETOF 记录：
+ `buffers_sent_last_minute` – 过去一分钟内发送到指定读取器的缓冲区数量。
+ `buffers_found_last_minute` – 在过去一分钟内识别的频繁访问缓冲区的数量。
+ `buffers_sent_last_scan` – 在上次完整扫描缓冲区缓存期间，发送到指定读取器的缓冲区数量。
+ `buffers_found_last_scan` – 在上次完整扫描缓冲区缓存期间，发送的经常访问缓冲区数量。已在指定读取器上缓存的缓冲区不会发送。
+ `buffers_sent_current_scan` – 在当前的扫描期间发送的缓冲区数量。
+ `buffers_found_current_scan` – 在当前扫描中识别的经常访问缓冲区的数量。
+ `current_scan_progress` – 在当前的扫描期间，到现在已访问的缓冲区数量。
## 使用说明
您可以使用此功能来检查和监控集群缓存管理 (CCM) 功能。仅当 CCM 在 Aurora PostgreSQL 数据库集群上处于活动状态时，此函数才有效。要使用此函数，您需要连接到 Aurora PostgreSQL 数据库集群上的写入数据库实例。
为 Aurora PostgreSQL 数据库集群启用 CCM，方法是在集群的自定义数据库集群参数组中，将 `apg_ccm_enabled` 设置为 1。要了解如何操作，请参阅[配置集群缓存管理](AuroraPostgreSQL.cluster-cache-mgmt.md#AuroraPostgreSQL.cluster-cache-mgmt.Configure)。
当集群具有如下配置的 Aurora 读取器实例时，集群缓存管理在 Aurora PostgreSQL 数据库集群上处于活动状态：
+ Aurora 读取器实例使用与集群的写入器实例相同的数据库实例类类型和大小。
+ Aurora 读取器实例配置为集群的 Tier-0。如果集群有多个读取器，则这是唯一的 Tier-0 读取器。
将多个读取器设置为 Tier-0 将会禁用 CCM。CCM 禁用时，调用此函数将返回以下错误消息：
```
ERROR: Cluster Cache Manager is disabled
```
您也可以使用 PostgreSQL pg\$1buffercache 扩展来分析缓冲区缓存。有关更多信息，请参阅 PostgreSQL 文档中的 [pg\$1buffercache](https://www.postgresql.org/docs/current/pgbuffercache.html)。
有关更多信息，请参阅 [Aurora PostgreSQL 集群缓存管理简介](https://aws.amazon.com/blogs/database/introduction-to-aurora-postgresql-cluster-cache-management/)。
## 示例
以下示例显示了调用 `aurora_ccm_status` 函数的结果。此第一个示例显示了 CCM 统计数据。
```
=> SELECT * FROM aurora_ccm_status();
buffers_sent_last_minute | buffers_found_last_minute | buffers_sent_last_scan | buffers_found_last_scan | buffers_sent_current_scan | buffers_found_current_scan | current_scan_progress
--------------------------+---------------------------+------------------------+-------------------------+---------------------------+----------------------------+-----------------------
2242000 | 2242003 | 17920442 | 17923410 | 14098000 | 14100964 | 15877443
```
有关更完整的详细信息，您可以使用扩展显示，如下所示：
```
\x
Expanded display is on.
SELECT * FROM aurora_ccm_status();
[ RECORD 1 ]-----------------------+---------
buffers_sent_last_minute | 2242000
buffers_found_last_minute | 2242003
buffers_sent_last_scan | 17920442
buffers_found_last_scan | 17923410
buffers_sent_current_scan | 14098000
buffers_found_current_scan | 14100964
current_scan_progress | 15877443
```
此示例说明如何检查温速率和温百分比。
```
=> SELECT buffers_sent_last_minute * 8/60 AS warm_rate_kbps,
100 * (1.0-buffers_sent_last_scan/buffers_found_last_scan) AS warm_percent
FROM aurora_ccm_status ();
warm_rate_kbps | warm_percent
----------------+--------------
16523 | 100.0
```
# aurora\$1global\$1db\$1instance\$1status
显示所有 Aurora 实例的状态，包括 Aurora 全局数据库集群中的副本。
## 语法
```
aurora_global_db_instance_status()
```
## 参数
无
## 返回类型
包含以下列的 SETOF 记录：
+ `server_id` – 数据库实例的标识符。
+ `session_id` – 当前会话的唯一标识符。`MASTER_SESSION_ID` 的值标识写入器（主要）数据库实例。
+ `aws_region` – 此全球数据库实例在其中运行的 AWS 区域。有关区域列表，请参阅[区域可用性](Concepts.RegionsAndAvailabilityZones.md#Aurora.Overview.Availability)。
+ `durable_lsn` – 在存储中变得持久的日志序列号（LSN）。日志序列号 (LSN) 是标识数据库事务日志中的记录的唯一序列号。对 LSN 进行排序，以便较大的 LSN 表示较晚的事务。
+ `highest_lsn_rcvd` – 数据库实例从写入器数据库实例收到的最高 LSN。
+ `feedback_epoch` – 数据库实例在生成热备用信息时使用的纪元。*热备用服务器*是在主数据库处于恢复或备用模式时支持连接和查询的数据库实例。热备用服务器信息包括纪元（时间点）和有关用作热备用服务器的数据库实例的其他详细信息。有关更多信息，请参阅 PostgreSQL 文档中的[热备用](https://www.postgresql.org/docs/current/hot-standby.html)。
+ `feedback_xmin` – 数据库实例使用的最小（最早）活动事务 ID。
+ `oldest_read_view_lsn` – 数据库实例用于从存储中读取的最早 LSN。
+ `visibility_lag_in_msec` – 此数据库实例滞后于写入器数据库实例的时间（以毫秒为单位）。
## 使用说明
此函数显示 Aurora 数据库集群的复制统计数据。对于集群中的每个 Aurora PostgreSQL 数据库实例，该函数显示一行数据，其中包括全局数据库配置中的任何跨区域副本。
您可以从 Aurora PostgreSQL 数据库集群或 Aurora PostgreSQL 全局数据库中的任何实例运行此函数。该函数返回有关所有副本实例滞后的详细信息。
要了解有关使用此函数（`aurora_global_db_instance_status`）或使用 `aurora_global_db_status` 监控滞后的更多信息，请参阅 [监控基于 Aurora PostgreSQL 的全局数据库](aurora-global-database-monitoring.md#aurora-global-database-monitoring.postgres)。
有关 Aurora 全局数据库的信息，请参阅[Amazon Aurora Global Database 概览](aurora-global-database.md#aurora-global-database-overview)。
要开始使用 Aurora 全局数据库，请参阅 [开始使用 Amazon Aurora Global Database](aurora-global-database-getting-started.md) 或参阅 [Amazon Aurora 常见问题](https://aws.amazon.com/rds/aurora/faqs/)。
## 示例
此示例显示跨区域实例统计数据。
```
=> SELECT *
FROM aurora_global_db_instance_status();
server_id | session_id | aws_region | durable_lsn | highest_lsn_rcvd | feedback_epoch | feedback_xmin | oldest_read_view_lsn | visibility_lag_in_msec
------------------------------------------+--------------------------------------+--------------+-------------+------------------+----------------+---------------+----------------------+------------------------
db-119-001-instance-01 | MASTER_SESSION_ID | eu-west-1 | 2534560273 | [NULL] | [NULL] | [NULL] | [NULL] | [NULL]
db-119-001-instance-02 | 4ecff34d-d57c-409c-ba28-278b31d6fc40 | eu-west-1 | 2534560266 | 2534560273 | 0 | 19669196 | 2534560266 | 6
db-119-001-instance-03 | 3e8a20fc-be86-43d5-95e5-bdf19d27ad6b | eu-west-1 | 2534560266 | 2534560273 | 0 | 19669196 | 2534560266 | 6
db-119-001-instance-04 | fc1b0023-e8b4-4361-bede-2a7e926cead6 | eu-west-1 | 2534560266 | 2534560273 | 0 | 19669196 | 2534560254 | 23
db-119-001-instance-05 | 30319b74-3f08-4e13-9728-e02aa1aa8649 | eu-west-1 | 2534560266 | 2534560273 | 0 | 19669196 | 2534560254 | 23
db-119-001-global-instance-1 | a331ffbb-d982-49ba-8973-527c96329c60 | eu-central-1 | 2534560254 | 2534560266 | 0 | 19669196 | 2534560247 | 996
db-119-001-global-instance-1 | e0955367-7082-43c4-b4db-70674064a9da | eu-west-2 | 2534560254 | 2534560266 | 0 | 19669196 | 2534560247 | 14
db-119-001-global-instance-1-eu-west-2a | 1248dc12-d3a4-46f5-a9e2-85850491a897 | eu-west-2 | 2534560254 | 2534560266 | 0 | 19669196 | 2534560247 | 0
```
此示例说明如何检查全局副本滞后（以毫秒为单位）。
```
=> SELECT CASE
WHEN 'MASTER_SESSION_ID' = session_id THEN 'Primary'
ELSE 'Secondary'
END AS global_role,
aws_region,
server_id,
visibility_lag_in_msec
FROM aurora_global_db_instance_status()
ORDER BY 1, 2, 3;
global_role | aws_region | server_id | visibility_lag_in_msec
-------------+--------------+-----------------------------------------+------------------------
Primary | eu-west-1 | db-119-001-instance-01 | [NULL]
Secondary | eu-central-1 | db-119-001-global-instance-1 | 13
Secondary | eu-west-1 | db-119-001-instance-02 | 10
Secondary | eu-west-1 | db-119-001-instance-03 | 9
Secondary | eu-west-1 | db-119-001-instance-04 | 2
Secondary | eu-west-1 | db-119-001-instance-05 | 18
Secondary | eu-west-2 | db-119-001-global-instance-1 | 14
Secondary | eu-west-2 | db-119-001-global-instance-1-eu-west-2a | 13
```
此示例说明如何从全局数据库配置中检查每个 AWS 区域 的最小、最大和平均滞后。
```
=> SELECT 'Secondary' global_role,
aws_region,
min(visibility_lag_in_msec) min_lag_in_msec,
max(visibility_lag_in_msec) max_lag_in_msec,
round(avg(visibility_lag_in_msec),0) avg_lag_in_msec
FROM aurora_global_db_instance_status()
WHERE aws_region NOT IN (SELECT aws_region
FROM aurora_global_db_instance_status()
WHERE session_id='MASTER_SESSION_ID')
GROUP BY aws_region
UNION ALL
SELECT 'Primary' global_role,
aws_region,
NULL,
NULL,
NULL
FROM aurora_global_db_instance_status()
WHERE session_id='MASTER_SESSION_ID'
ORDER BY 1, 5;
global_role | aws_region | min_lag_in_msec | max_lag_in_msec | avg_lag_in_msec
------------+--------------+-----------------+-----------------+-----------------
Primary | eu-west-1 | [NULL] | [NULL] | [NULL]
Secondary | eu-central-1 | 133 | 133 | 133
Secondary | eu-west-2 | 0 | 495 | 248
```
# aurora\$1global\$1db\$1status
显示有关 Aurora 全局数据库滞后各方面的信息，特别是底层 Aurora 存储的滞后（所谓持久性滞后）以及恢复点目标（RPO）之间的滞后。
## 语法
```
aurora_global_db_status()
```
## 参数
无。
## 返回类型
包含以下列的 SETOF 记录：
+ `aws_region` – 此数据库集群所在的 AWS 区域。有关按引擎排列的完整 AWS 区域列表，请参阅[ 区域及可用区](Concepts.RegionsAndAvailabilityZones.md)。
+ `highest_lsn_written` – 此数据库集群上当前存在的最高日志序列号（LSN）。日志序列号 (LSN) 是标识数据库事务日志中的记录的唯一序列号。对 LSN 进行排序，以便较大的 LSN 表示较晚的事务。
+ `durability_lag_in_msec` – 辅助数据库集群上的 `highest_lsn_written` 与主数据库集群上的 `highest_lsn_written` 之间的时间戳值差异。值为 -1 表示 Aurora 全局数据库的主数据库集群。
+ `rpo_lag_in_msec` – 恢复点目标（RPO）滞后。RPO 滞后是最近的用户事务在存储在 Aurora 全局数据库的主数据库集群上之后，执行 COMMIT 操作以便存储在辅助数据库集群上所需的时间。值为 -1 表示主数据库集群（因此滞后无关紧要）。
简而言之，该指标计算 Aurora 全局数据库中每个 Aurora PostgreSQL 数据库集群的恢复点目标，即如果发生中断，可能会丢失多少数据。与滞后一样，RPO 是按时间计量的。
+ `last_lag_calculation_time` – 指定上次为 `durability_lag_in_msec` 和 `rpo_lag_in_msec` 计算值的时间戳。时间值（如 `1970-01-01 00:00:00+00`）表示这是主数据库集群。
+ `feedback_epoch` – 辅助数据库集群在生成热备用信息时使用的纪元。*热备用服务器*是在主数据库处于恢复或备用模式时支持连接和查询的数据库实例。热备用服务器信息包括纪元（时间点）和有关用作热备用服务器的数据库实例的其他详细信息。有关更多信息，请参阅 PostgreSQL 文档中的[热备用](https://www.postgresql.org/docs/current/hot-standby.html)。
+ `feedback_xmin` – 辅助数据库集群使用的最小（最早）活动事务 ID。
## 使用说明
Aurora PostgreSQL 的当前所有可用版本都支持此功能。此函数显示 Aurora 全局数据库的复制统计数据。它为 Aurora PostgreSQL 全局数据库中的每个数据库集群显示一行。您可以从 Aurora PostgreSQL 全局数据库中的任何实例运行此函数。
要评估 Aurora 全局数据库复制滞后（即可见的数据滞后），请参阅 [aurora\$1global\$1db\$1instance\$1status](aurora_global_db_instance_status.md)。
要了解有关使用 `aurora_global_db_status` 和 `aurora_global_db_instance_status` 监控 Aurora 全局数据库滞后的更多信息，请参阅 [监控基于 Aurora PostgreSQL 的全局数据库](aurora-global-database-monitoring.md#aurora-global-database-monitoring.postgres)。有关 Aurora 全局数据库的信息，请参阅[Amazon Aurora Global Database 概览](aurora-global-database.md#aurora-global-database-overview)。
## 示例
此示例说明如何显示跨区域存储统计数据。
```
=> SELECT CASE
WHEN '-1' = durability_lag_in_msec THEN 'Primary'
ELSE 'Secondary'
END AS global_role,
*
FROM aurora_global_db_status();
global_role | aws_region | highest_lsn_written | durability_lag_in_msec | rpo_lag_in_msec | last_lag_calculation_time | feedback_epoch | feedback_xmin
-------------+------------+---------------------+------------------------+-----------------+----------------------------+----------------+---------------
Primary | eu-west-1 | 131031557 | -1 | -1 | 1970-01-01 00:00:00+00 | 0 | 0
Secondary | eu-west-2 | 131031554 | 410 | 0 | 2021-06-01 18:59:36.124+00 | 0 | 12640
Secondary | eu-west-3 | 131031554 | 410 | 0 | 2021-06-01 18:59:36.124+00 | 0 | 12640
```
# aurora\$1list\$1builtins
列出所有可用的 Aurora PostgreSQL 内置函数，以及简要说明和函数详细信息。
## 语法
```
aurora_list_builtins()
```
## 参数
无
## 返回类型
SETOF 记录
## 示例
以下示例显示了调用 `aurora_list_builtins` 函数的结果。
```
=> SELECT *
FROM aurora_list_builtins();
Name | Result data type | Argument data types | Type | Volatility | Parallel | Security | Description
-----------------------------------+------------------+----------------------------------------------------------+------+------------+------------+----------+---------------------------------------------------------------------
aurora_version | text | | func | stable | safe | invoker | Amazon Aurora PostgreSQL-Compatible Edition version string
aurora_stat_wait_type | SETOF record | OUT type_id smallint, OUT type_name text | func | volatile | restricted | invoker | Lists all supported wait types
aurora_stat_wait_event | SETOF record | OUT type_id smallint, OUT event_id integer, OUT event_na.| func | volatile | restricted | invoker | Lists all supported wait events
| |.me text | | | | |
aurora_list_builtins | SETOF record | OUT "Name" text, OUT "Result data type" text, OUT "Argum.| func | stable | safe | invoker | Lists all Aurora built-in functions
| |.ent data types" text, OUT "Type" text, OUT "Volatility" .| | | | |
| |.text, OUT "Parallel" text, OUT "Security" text, OUT "Des.| | | | |
| |.cription" text | | | | |
.
.
.
aurora_stat_file | SETOF record | OUT filename text, OUT allocated_bytes bigint, OUT used_.| func | stable | safe | invoker | Lists all files present in Aurora storage
| |.bytes bigint | | | | |
aurora_stat_get_db_commit_latency | bigint | oid | func | stable | restricted | invoker | Per DB commit latency in microsecs
```
# aurora\$1replica\$1status
显示所有 Aurora PostgreSQL 读取器节点的状态。
## 语法
```
aurora_replica_status()
```
## 参数
无
## 返回类型
包含以下列的 SETOF 记录：
+ `server_id` – 数据库实例 ID（标识符）。
+ `session_id` – 当前会话的唯一标识符，针对主实例和读取器实例返回，如下所示：
+ 对于主实例，`session_id` 始终为 ``MASTER_SESSION_ID’`。
+ 对于读取器实例，`session_id` 始终为读取器实例的 `UUID`（通用唯一标识符）。
+ `durable_lsn` – 保存在存储中的日志序列号 (LSN) 。
+ 对于主卷，该值是当前生效的主卷持久性 LSN (VDL) 。
+ 对于任何辅助卷，该值是已成功应用辅助卷的主卷的 VDL。
**注意**
日志序列号 (LSN) 是标识数据库事务日志中的记录的唯一序列号。对 LSN 进行排序，以便较大的 LSN 表示序列中较晚发生的事务。
+ `highest_lsn_rcvd` – 数据库实例从写入器数据库实例收到的最高（最新）LSN。
+ `current_read_lsn` – 应用于所有读取器的最新快照的 LSN。
+ `cur_replay_latency_in_usec` – 在辅助卷上重播日志所需的微秒数。
+ `active_txns` – 当前处于活动状态的事务数量。
+ `is_current` – 未使用。
+ `last_transport_error` – 上次复制错误代码。
+ `last_error_timestamp` – 上次复制错误的时间戳。
+ `last_update_timestamp` – 上次更新副本状态的时间戳。在 Aurora PostgreSQL 13.9 中，您所连接的数据库实例的 `last_update_timestamp` 值设置为 `NULL`。
+ `feedback_xmin` – 副本的热备用 feedback\$1xmin。数据库实例使用的最小（最早）活动事务 ID。
+ `feedback_epoch` – 数据库实例在生成热备用信息时使用的纪元。
+ `replica_lag_in_msec` – 读取器实例滞后于写入器实例的时间（以毫秒为单位）。
+ `log_stream_speed_in_kib_per_second` – 日志流吞吐量（以每秒千字节为单位）。
+ `log_buffer_sequence_number` – 日志缓冲区序列号。
+ `oldest_read_view_trx_id` – 未使用。
+ `oldest_read_view_lsn` – 数据库实例用于从存储中读取的最早 LSN。
+ `pending_read_ios` – 未完成的页面读取在副本上仍处于待处理状态。
+ `read_ios` – 副本上的页面读取总数。
+ `iops` – 未使用。
+ `cpu` – 集群中每个节点的 Aurora 存储进程守护程序的 CPU 使用率。有关实例的 CPU 使用情况的信息，请参阅[Amazon Aurora 的实例级指标](Aurora.AuroraMonitoring.Metrics.md#Aurora.AuroraMySQL.Monitoring.Metrics.instances)。
## 使用说明
Aurora PostgreSQL 的当前所有可用版本都支持此功能。`aurora_replica_status` 函数从 Aurora PostgreSQL 数据库集群的副本状态管理器返回值。您可以使用此函数获取有关 Aurora PostgreSQL 数据库集群上复制状态的信息，包括 Aurora 数据库集群中所有数据库实例的指标。例如，您可以执行以下操作：
+ **获取有关 Aurora PostgreSQL 数据库集群中实例类型（写入器、读取器）的信息** – 您可以通过检查以下列的值来获取此信息：
+ `server_id` – 包含创建实例时指定的实例名称。在某些情况下，例如对于主（写入器）实例，通常会通过在为 Aurora PostgreSQL 数据库集群创建的名称后面附加 *-instance-1* 来为您创建名称。
+ `session_id` – `session_id` 字段指示实例是读取器还是写入器。对于写入器实例，`session_id` 始终设置为 `"MASTER_SESSION_ID"`。对于读取器实例，`session_id` 已设置为特定读取器的 `UUID`。
+ **诊断常见的复制问题，例如副本滞后** – 副本滞后是指读取器实例的页面缓存落后于写入器实例页面缓存的时间（以毫秒为单位）。出现此滞后的原因是 Aurora 集群使用异步复制，如 [使用 Amazon Aurora 进行复制](Aurora.Replication.md)中所述。它显示在该函数返回的结果中的 `replica_lag_in_msec` 列中。当由于与备用服务器上的恢复冲突而取消查询时，也可能会发生滞后。您可以检查 `pg_stat_database_conflicts()` 以验证此类冲突是否导致副本滞后。有关更多信息，请参阅 *PostgreSQL 文档*中的[统计数据收集器](https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-DATABASE-CONFLICTS-VIEW)。要了解有关高可用性和复制的更多信息，请参阅 [Amazon Aurora 常见问题](https://aws.amazon.com/rds/aurora/faqs/#High_Availability_and_Replication)。
Amazon CloudWatch 会随着时间的推移存储 `replica_lag_in_msec` 结果，作为 `AuroraReplicaLag` 指标。有关将 CloudWatch 指标用于 Aurora 的信息，请参阅[使用 Amazon CloudWatch 监控 Amazon Aurora 指标](monitoring-cloudwatch.md)。
要了解有关 Aurora 只读副本故障排查和重新启动的更多信息，请参阅 [AWS 支持 中心](https://console.aws.amazon.com/support/home#/)内的[为什么我的 Amazon Aurora 只读副本滞后并重新启动？](https://aws.amazon.com/premiumsupport/knowledge-center/aurora-read-replica-restart/)
## 示例
以下示例说明如何获取 Aurora PostgreSQL 数据库集群中所有实例的复制状态：
```
=> SELECT *
FROM aurora_replica_status();
```
以下示例显示 `docs-lab-apg-main` Aurora PostgreSQL 数据库集群中的写入器实例：
```
=> SELECT server_id,
CASE
WHEN 'MASTER_SESSION_ID' = session_id THEN 'writer'
ELSE 'reader'
END AS instance_role
FROM aurora_replica_status()
WHERE session_id = 'MASTER_SESSION_ID';
server_id | instance_role
------------------------+---------------
db-119-001-instance-01 | writer
```
以下示例列出集群中的所有读取器实例：
```
=> SELECT server_id,
CASE
WHEN 'MASTER_SESSION_ID' = session_id THEN 'writer'
ELSE 'reader'
END AS instance_role
FROM aurora_replica_status()
WHERE session_id <> 'MASTER_SESSION_ID';
server_id | instance_role
------------------------+---------------
db-119-001-instance-02 | reader
db-119-001-instance-03 | reader
db-119-001-instance-04 | reader
db-119-001-instance-05 | reader
(4 rows)
```
以下示例列出所有实例、每个实例滞后于写入器的程度，以及自上次更新以来经过的时间：
```
=> SELECT server_id,
CASE
WHEN 'MASTER_SESSION_ID' = session_id THEN 'writer'
ELSE 'reader'
END AS instance_role,
replica_lag_in_msec AS replica_lag_ms,
round(extract (epoch FROM (SELECT age(clock_timestamp(), last_update_timestamp))) * 1000) AS last_update_age_ms
FROM aurora_replica_status()
ORDER BY replica_lag_in_msec NULLS FIRST;
server_id | instance_role | replica_lag_ms | last_update_age_ms
------------------------+---------------+----------------+--------------------
db-124-001-instance-03 | writer | [NULL] | 1756
db-124-001-instance-01 | reader | 13 | 1756
db-124-001-instance-02 | reader | 13 | 1756
(3 rows)
```
# aurora\$1stat\$1activity
每个服务器进程返回一行，显示与该进程的当前活动相关的信息。
## 语法
```
aurora_stat_activity();
```
## 参数
无
## 返回类型
每个服务器进程返回一行。除了 `pg_stat_activity` 列之外，还添加了以下字段：
+ planid：计划标识符
## 使用说明
`pg_stat_activity` 的一个补充视图，可返回相同的列以及显示当前查询执行计划的额外 `plan_id` 列。
必须启用 `aurora_compute_plan_id`，视图才能返回 plan\$1id。
Aurora PostgreSQL 版本 14.10、15.5 以及所有其它更高版本都提供了此函数。
## 示例
下面的示例查询按 query\$1id 和 plan\$1id 汇总了最高负载。
```
db1=# select count(*), query_id, plan_id
db1-# from aurora_stat_activity() where state = 'active'
db1-# and pid <> pg_backend_pid()
db1-# group by query_id, plan_id
db1-# order by 1 desc;
count | query_id | plan_id
-------+----------------------+-------------
11 | -5471422286312252535 | -2054628807
3 | -6907107586630739258 | -815866029
1 | 5213711845501580017 | 300482084
(3 rows)
```
如果用于 query\$1id 的计划发生变化，aurora\$1stat\$1activity 将报告新的 plan\$1id。
```
count | query_id | plan_id
-------+----------------------+-------------
10 | -5471422286312252535 | 1602979607
1 | -6907107586630739258 | -1809935983
1 | -2446282393000597155 | -207532066
(3 rows)
```
# aurora\$1stat\$1backend\$1wait
显示特定后端进程等待活动的统计数据。
## 语法
```
aurora_stat_backend_waits(pid)
```
## 参数
`pid` – 后端进程的 ID。您可以通过使用 `pg_stat_activity` 视图获取进程 ID。
## 返回类型
包含以下列的 SETOF 记录：
+ `type_id` – 表示等待事件类型的数字，例如 `1` 表示轻量级锁（`LWLock`），`3` 表示锁，或者 `6` 表示客户端会话。当您将此函数的结果与 `aurora_stat_wait_type` 函数中的列连接时，这些值变得有意义，如[示例](#aurora_stat_backend_waits-examples)中所示。
+ `event_id` – 等待事件的识别号码。将此值与来自 `aurora_stat_wait_event` 的列连接以获取有意义的事件名称。
+ `waits` – 指定进程 ID 累积的等待次数的计数。
+ `wait_time` – 以毫秒为单位的等待时间。
## 使用说明
您可以使用此函数分析自连接打开以来发生的特定后端（会话）等待事件。要获取更多有关等待事件名称和类型的有意义信息，您可以通过使用 JOIN 组合此函数 `aurora_stat_wait_type` 和 `aurora_stat_wait_event`，如示例所示。
## 示例
此示例显示了后端进程 ID 3027 的所有等待、类型和事件名称。
```
=> SELECT type_name, event_name, waits, wait_time
FROM aurora_stat_backend_waits(3027)
NATURAL JOIN aurora_stat_wait_type()
NATURAL JOIN aurora_stat_wait_event();
type_name | event_name | waits | wait_time
-----------+------------------------+-------+------------
LWLock | ProcArrayLock | 3 | 27
LWLock | wal_insert | 423 | 16336
LWLock | buffer_content | 11840 | 1033634
LWLock | lock_manager | 23821 | 5664506
Lock | tuple | 10258 | 152280165
Lock | transactionid | 78340 | 1239808783
Client | ClientRead | 34072 | 17616684
IO | ControlFileSyncUpdate | 2 | 0
IO | ControlFileWriteUpdate | 4 | 32
IO | RelationMapRead | 2 | 795
IO | WALWrite | 36666 | 98623
IO | XactSync | 4867 | 7331963
```
此示例显示了所有活动会话的当前和累积等待类型及等待事件（`pg_stat_activity state <> 'idle'`）[但不包括调用此函数的当前会话（`pid <> pg_backend_pid()`）]。
```
=> SELECT a.pid,
a.usename,
a.app_name,
a.current_wait_type,
a.current_wait_event,
a.current_state,
wt.type_name AS wait_type,
we.event_name AS wait_event,
a.waits,
a.wait_time
FROM (SELECT pid,
usename,
left(application_name,16) AS app_name,
coalesce(wait_event_type,'CPU') AS current_wait_type,
coalesce(wait_event,'CPU') AS current_wait_event,
state AS current_state,
(aurora_stat_backend_waits(pid)).*
FROM pg_stat_activity
WHERE pid <> pg_backend_pid()
AND state <> 'idle') a
NATURAL JOIN aurora_stat_wait_type() wt
NATURAL JOIN aurora_stat_wait_event() we;
pid | usename | app_name | current_wait_type | current_wait_event | current_state | wait_type | wait_event | waits | wait_time
-------+----------+----------+-------------------+--------------------+---------------+-----------+------------------------+-------+-----------
30099 | postgres | pgbench | Lock | transactionid | active | LWLock | wal_insert | 1937 | 29975
30099 | postgres | pgbench | Lock | transactionid | active | LWLock | buffer_content | 22903 | 760498
30099 | postgres | pgbench | Lock | transactionid | active | LWLock | lock_manager | 10012 | 223207
30099 | postgres | pgbench | Lock | transactionid | active | Lock | tuple | 20315 | 63081529
.
.
.
30099 | postgres | pgbench | Lock | transactionid | active | IO | WALWrite | 93293 | 237440
30099 | postgres | pgbench | Lock | transactionid | active | IO | XactSync | 13010 | 19525143
30100 | postgres | pgbench | Lock | transactionid | active | LWLock | ProcArrayLock | 6 | 53
30100 | postgres | pgbench | Lock | transactionid | active | LWLock | wal_insert | 1913 | 25450
30100 | postgres | pgbench | Lock | transactionid | active | LWLock | buffer_content | 22874 | 778005
.
.
.
30109 | postgres | pgbench | IO | XactSync | active | LWLock | ProcArrayLock | 3 | 71
30109 | postgres | pgbench | IO | XactSync | active | LWLock | wal_insert | 1940 | 27741
30109 | postgres | pgbench | IO | XactSync | active | LWLock | buffer_content | 22962 | 776352
30109 | postgres | pgbench | IO | XactSync | active | LWLock | lock_manager | 9879 | 218826
30109 | postgres | pgbench | IO | XactSync | active | Lock | tuple | 20401 | 63581306
30109 | postgres | pgbench | IO | XactSync | active | Lock | transactionid | 50769 | 211645008
30109 | postgres | pgbench | IO | XactSync | active | Client | ClientRead | 89901 | 44192439
```
此示例显示了所有活动会话的当前和前三（3）个累积等待类型和等待事件（`pg_stat_activity state <> 'idle'`），不包括当前会话（`pid <>pg_backend_pid()`）。
```
=> SELECT top3.*
FROM (SELECT a.pid,
a.usename,
a.app_name,
a.current_wait_type,
a.current_wait_event,
a.current_state,
wt.type_name AS wait_type,
we.event_name AS wait_event,
a.waits,
a.wait_time,
RANK() OVER (PARTITION BY pid ORDER BY a.wait_time DESC)
FROM (SELECT pid,
usename,
left(application_name,16) AS app_name,
coalesce(wait_event_type,'CPU') AS current_wait_type,
coalesce(wait_event,'CPU') AS current_wait_event,
state AS current_state,
(aurora_stat_backend_waits(pid)).*
FROM pg_stat_activity
WHERE pid <> pg_backend_pid()
AND state <> 'idle') a
NATURAL JOIN aurora_stat_wait_type() wt
NATURAL JOIN aurora_stat_wait_event() we) top3
WHERE RANK <=3;
pid | usename | app_name | current_wait_type | current_wait_event | current_state | wait_type | wait_event | waits | wait_time | rank
-------+----------+----------+-------------------+--------------------+---------------+-----------+-----------------+---------+------------+------
20567 | postgres | psql | CPU | CPU | active | LWLock | wal_insert | 25000 | 67512003 | 1
20567 | postgres | psql | CPU | CPU | active | IO | WALWrite | 3071758 | 1016961 | 2
20567 | postgres | psql | CPU | CPU | active | IO | BufFileWrite | 20750 | 184559 | 3
27743 | postgres | pgbench | Lock | transactionid | active | Lock | transactionid | 237350 | 1265580011 | 1
27743 | postgres | pgbench | Lock | transactionid | active | Lock | tuple | 93641 | 341472318 | 2
27743 | postgres | pgbench | Lock | transactionid | active | Client | ClientRead | 417556 | 204796837 | 3
.
.
.
27745 | postgres | pgbench | IO | XactSync | active | Lock | transactionid | 238068 | 1265816822 | 1
27745 | postgres | pgbench | IO | XactSync | active | Lock | tuple | 93210 | 338312247 | 2
27745 | postgres | pgbench | IO | XactSync | active | Client | ClientRead | 419157 | 207836533 | 3
27746 | postgres | pgbench | Lock | transactionid | active | Lock | transactionid | 237621 | 1264528811 | 1
27746 | postgres | pgbench | Lock | transactionid | active | Lock | tuple | 93563 | 339799310 | 2
27746 | postgres | pgbench | Lock | transactionid | active | Client | ClientRead | 417304 | 208372727 | 3
```
# aurora\$1stat\$1bgwriter
`aurora_stat_bgwriter` 是一个统计视图，显示有关优化型读取缓存写入的信息。
## 语法
```
aurora_stat_bgwriter()
```
## 参数
无
## 返回类型
包含所有 `pg_stat_bgwriter` 列和以下附加列的 SETOF 记录。有关 `pg_stat_bgwriter` 列的更多信息，请参阅 [https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-BGWRITER-VIEW](https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-BGWRITER-VIEW)。
您可以使用 `pg_stat_reset_shared("bgwriter")` 重置此函数的统计信息。
+ `orcache_blks_written` – 已写入的优化型读取缓存数据块的总数。
+ `orcache_blk_write_time` – 如果已启用 `track_io_timing`，它将跟踪写入优化型读取缓存数据文件块所花费的总时间（以毫秒为单位）。有关更多信息，请参阅 [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING)。
## 使用说明
此函数可用于以下 Aurora PostgreSQL 版本：
+ 15.4 及更高的 15 版本
+ 14.9 及更高的 14 版本
## 示例
```
=> select * from aurora_stat_bgwriter();
-[ RECORD 1 ]-----------------+-----------
orcache_blks_written | 246522
orcache_blk_write_time | 339276.404
```
# aurora\$1stat\$1database
它携带 pg\$1stat\$1database 的所有列，并在最后添加新列。
## 语法
```
aurora_stat_database()
```
## 参数
无
## 返回类型
包含所有 `pg_stat_database` 列和以下附加列的 SETOF 记录。有关 `pg_stat_database` 列的更多信息，请参阅 [https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-DATABASE-VIEW](https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-DATABASE-VIEW)。
+ `storage_blks_read` – 从该数据库的 aurora 存储中读取的共享块总数。
+ `orcache_blks_hit` – 此数据库中优化型读取缓存命中总数。
+ `local_blks_read` – 在此数据库中读取的本地块总数。
+ `storage_blk_read_time` – 如果已启用 `track_io_timing`，它将跟踪从 aurora 存储中读取数据文件块所花费的总时间（以毫秒为单位），否则该值为零。有关更多信息，请参阅 [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING)。
+ `local_blk_read_time` – 如果已启用 `track_io_timing`，它将跟踪读取本地数据文件块所花费的总时间（以毫秒为单位），否则该值为零。有关更多信息，请参阅 [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING)。
+ `orcache_blk_read_time` – 如果已启用 `track_io_timing`，它将跟踪从优化型读取缓存中读取数据文件块所花费的总时间（以毫秒为单位），否则该值为零。有关更多信息，请参阅 [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING)。
**注意**
`blks_read` 的值是`storage_blks_read`、`orcache_blks_hit` 和 `local_blks_read` 的总和。
`blk_read_time` 的值是`storage_blk_read_time`、`orcache_blk_read_time` 和 `local_blk_read_time` 的总和。
## 使用说明
此函数可用于以下 Aurora PostgreSQL 版本：
+ 15.4 及更高的 15 版本
+ 14.9 及更高的 14 版本
## 示例
以下示例显示了它如何携带所有 `pg_stat_database` 列并在最后附加 6 个新列：
```
=> select * from aurora_stat_database() where datid=14717;
-[ RECORD 1 ]------------+------------------------------
datid | 14717
datname | postgres
numbackends | 1
xact_commit | 223
xact_rollback | 4
blks_read | 1059
blks_hit | 11456
tup_returned | 27746
tup_fetched | 5220
tup_inserted | 165
tup_updated | 42
tup_deleted | 91
conflicts | 0
temp_files | 0
temp_bytes | 0
deadlocks | 0
checksum_failures |
checksum_last_failure |
blk_read_time | 3358.689
blk_write_time | 0
session_time | 1076007.997
active_time | 3684.371
idle_in_transaction_time | 0
sessions | 10
sessions_abandoned | 0
sessions_fatal | 0
sessions_killed | 0
stats_reset | 2023-01-12 20:15:17.370601+00
orcache_blks_hit | 425
orcache_blk_read_time | 89.934
storage_blks_read | 623
storage_blk_read_time | 3254.914
local_blks_read | 0
local_blk_read_time | 0
```
# aurora\$1stat\$1dml\$1activity
报告 Aurora PostgreSQL 集群中数据库上每种类型的数据操作语言（DML）操作的累积活动。
## 语法
```
aurora_stat_dml_activity(database_oid)
```
## 参数
*database\$1oid*
Aurora PostgreSQL 集群中数据库的对象 ID（OID）。
## 返回类型
SETOF 记录
## 使用说明
`aurora_stat_dml_activity` 函数仅适用于 Aurora PostgreSQL 版本 3.1，与 PostgreSQL 引擎 11.6 及更高版本兼容。
在具有大量数据库的 Aurora PostgreSQL 集群上使用此函数，以确定哪些数据库具有更多或更慢的 DML 活动，或两者兼有。
`aurora_stat_dml_activity` 函数返回运行操作的次数以及选择、插入、更新和删除操作的累积延迟（以微秒为单位）。该报告仅包括成功的 DML 操作。
您可以使用 PostgreSQL 统计信息访问函数 `pg_stat_reset` 重置此统计信息。您可以使用 `pg_stat_get_db_stat_reset_time` 函数检查上次重置此统计信息的时间。有关 PostgreSQL 统计访问函数的更多信息，请参阅 PostgreSQL 文档中的[统计收集器](https://www.postgresql.org/docs/9.1/monitoring-stats.html)。
## 示例
以下示例说明如何报告连接的数据库的 DML 活动统计数据库。
```
––Define the oid variable from connected database by using \gset
=> SELECT oid,
datname
FROM pg_database
WHERE datname=(select current_database()) \gset
=> SELECT *
FROM aurora_stat_dml_activity(:oid);
select_count | select_latency_microsecs | insert_count | insert_latency_microsecs | update_count | update_latency_microsecs | delete_count | delete_latency_microsecs
--------------+--------------------------+--------------+--------------------------+--------------+--------------------------+--------------+--------------------------
178957 | 66684115 | 171065 | 28876649 | 519538 | 1454579206167 | 1 | 53027
–– Showing the same results with expanded display on
=> SELECT *
FROM aurora_stat_dml_activity(:oid);
-[ RECORD 1 ]------------+--------------
select_count | 178957
select_latency_microsecs | 66684115
insert_count | 171065
insert_latency_microsecs | 28876649
update_count | 519538
update_latency_microsecs | 1454579206167
delete_count | 1
delete_latency_microsecs | 53027
```
以下示例显示了 Aurora PostgreSQL 集群中所有数据库的 DML 活动统计信息。该集群有两个数据库 `postgres` 和 `mydb`。逗号分隔的列表对应 `select_count`、`select_latency_microsecs`、`insert_count`、`insert_latency_microsecs`、`update_count`、`update_latency_microsecs`、`delete_count` 和 `delete_latency_microsecs` 字段。
Aurora PostgreSQL 创建并使用名为 `rdsadmin` 的系统数据库来支持管理操作，例如备份、还原、运行状况检查、复制等。这些 DML 操作对您的 Aurora PostgreSQL 集群没有任何影响。
```
=> SELECT oid,
datname,
aurora_stat_dml_activity(oid)
FROM pg_database;
oid | datname | aurora_stat_dml_activity
-------+----------------+-----------------------------------------------------------------
14006 | template0 | (,,,,,,,)
16384 | rdsadmin | (2346623,1211703821,4297518,817184554,0,0,0,0)
1 | template1 | (,,,,,,,)
14007 | postgres | (178961,66716329,171065,28876649,519538,1454579206167,1,53027)
16401 | mydb | (200246,64302436,200036,107101855,600000,83659417514,0,0)
```
以下示例显示了所有数据库的 DML 活动统计信息，这些统计信息按列进行组织，以提高可读性。
```
SELECT db.datname,
BTRIM(SPLIT_PART(db.asdmla::TEXT, ',', 1), '()') AS select_count,
BTRIM(SPLIT_PART(db.asdmla::TEXT, ',', 2), '()') AS select_latency_microsecs,
BTRIM(SPLIT_PART(db.asdmla::TEXT, ',', 3), '()') AS insert_count,
BTRIM(SPLIT_PART(db.asdmla::TEXT, ',', 4), '()') AS insert_latency_microsecs,
BTRIM(SPLIT_PART(db.asdmla::TEXT, ',', 5), '()') AS update_count,
BTRIM(SPLIT_PART(db.asdmla::TEXT, ',', 6), '()') AS update_latency_microsecs,
BTRIM(SPLIT_PART(db.asdmla::TEXT, ',', 7), '()') AS delete_count,
BTRIM(SPLIT_PART(db.asdmla::TEXT, ',', 8), '()') AS delete_latency_microsecs
FROM (SELECT datname,
aurora_stat_dml_activity(oid) AS asdmla
FROM pg_database
) AS db;
datname | select_count | select_latency_microsecs | insert_count | insert_latency_microsecs | update_count | update_latency_microsecs | delete_count | delete_latency_microsecs
----------------+--------------+--------------------------+--------------+--------------------------+--------------+--------------------------+--------------+--------------------------
template0 | | | | | | | |
rdsadmin | 4206523 | 2478812333 | 7009414 | 1338482258 | 0 | 0 | 0 | 0
template1 | | | | | | | |
fault_test | 66 | 452099 | 0 | 0 | 0 | 0 | 0 | 0
db_access_test | 1 | 5982 | 0 | 0 | 0 | 0 | 0 | 0
postgres | 42035 | 95179203 | 5752 | 2678832898 | 21157 | 441883182488 | 2 | 1520
mydb | 71 | 453514 | 0 | 0 | 1 | 190 | 1 | 152
```
以下示例显示具有 OID `16401` 的数据库每个 DML 操作的平均累积延迟时间（累积延迟除以计数）。
```
=> SELECT select_count,
select_latency_microsecs,
select_latency_microsecs/NULLIF(select_count,0) select_latency_per_exec,
insert_count,
insert_latency_microsecs,
insert_latency_microsecs/NULLIF(insert_count,0) insert_latency_per_exec,
update_count,
update_latency_microsecs,
update_latency_microsecs/NULLIF(update_count,0) update_latency_per_exec,
delete_count,
delete_latency_microsecs,
delete_latency_microsecs/NULLIF(delete_count,0) delete_latency_per_exec
FROM aurora_stat_dml_activity(16401);
-[ RECORD 1 ]------------+-------------
select_count | 451312
select_latency_microsecs | 80205857
select_latency_per_exec | 177
insert_count | 451001
insert_latency_microsecs | 123667646
insert_latency_per_exec | 274
update_count | 1353067
update_latency_microsecs | 200900695615
update_latency_per_exec | 148478
delete_count | 12
delete_latency_microsecs | 448
delete_latency_per_exec | 37
```
# aurora\$1stat\$1get\$1db\$1commit\$1latency
获取 Aurora PostgreSQL 数据库的累积提交延迟时间（以微秒为单位）。按照为客户端提交提交请求到接收提交确认之间的时间测量*提交延迟*。
## 语法
```
aurora_stat_get_db_commit_latency(database_oid)
```
## 参数
*database\$1oid*
Aurora PostgreSQL 数据库的对象 ID（OID）。
## 返回类型
SETOF 记录
## 使用说明
Amazon CloudWatch 使用此函数来计算平均提交延迟。有关 Amazon CloudWatch 指标以及如何解决高提交延迟问题的更多信息，请参阅[在 Amazon RDS 控制台中查看指标](USER_Monitoring.md)和[使用 Amazon CloudWatch 指标更好地制定有关 Amazon RDS 的决策](https://aws.amazon.com/blogs/database/making-better-decisions-about-amazon-rds-with-amazon-cloudwatch-metrics/)。
您可以使用 PostgreSQL 统计信息访问函数 `pg_stat_reset` 重置此统计信息。您可以使用 `pg_stat_get_db_stat_reset_time` 函数检查上次重置此统计信息的时间。有关 PostgreSQL 统计访问函数的更多信息，请参阅 PostgreSQL 文档中的[统计收集器](https://www.postgresql.org/docs/9.1/monitoring-stats.html)。
## 示例
以下示例获取 `pg_database` 集群中每个数据库的累积提交延迟。
```
=> SELECT oid,
datname,
aurora_stat_get_db_commit_latency(oid)
FROM pg_database;
oid | datname | aurora_stat_get_db_commit_latency
-------+----------------+-----------------------------------
14006 | template0 | 0
16384 | rdsadmin | 654387789
1 | template1 | 0
16401 | mydb | 229556
69768 | postgres | 22011
```
以下示例获取当前连接的数据库的累积提交延迟。在调用 `aurora_stat_get_db_commit_latency` 函数之前，该示例首先使用 `\gset` 为参数定义 `oid` 变量并从连接的数据库中设置其值。
```
––Get the oid value from the connected database before calling aurora_stat_get_db_commit_latency
=> SELECT oid
FROM pg_database
WHERE datname=(SELECT current_database()) \gset
=> SELECT *
FROM aurora_stat_get_db_commit_latency(:oid);
aurora_stat_get_db_commit_latency
-----------------------------------
1424279160
```
以下示例获取 `pg_database` 集群中 `mydb` 数据库的累积提交延迟。然后，它使用 `pg_stat_reset` 函数重置此统计信息并显示结果。最后，它使用 `pg_stat_get_db_stat_reset_time` 函数来检查上次重置此统计信息的时间。
```
=> SELECT oid,
datname,
aurora_stat_get_db_commit_latency(oid)
FROM pg_database
WHERE datname = 'mydb';
oid | datname | aurora_stat_get_db_commit_latency
-------+-----------+-----------------------------------
16427 | mydb | 3320370
=> SELECT pg_stat_reset();
pg_stat_reset
---------------
=> SELECT oid,
datname,
aurora_stat_get_db_commit_latency(oid)
FROM pg_database
WHERE datname = 'mydb';
oid | datname | aurora_stat_get_db_commit_latency
-------+-----------+-----------------------------------
16427 | mydb | 6
=> SELECT *
FROM pg_stat_get_db_stat_reset_time(16427);
pg_stat_get_db_stat_reset_time
--------------------------------
2021-04-29 21:36:15.707399+00
```
# aurora\$1stat\$1logical\$1wal\$1cache
显示每个插槽的逻辑预写日志（WAL）缓存使用情况。
## 语法
```
SELECT * FROM aurora_stat_logical_wal_cache()
```
## 参数
无
## 返回类型
包含以下列的 SETOF 记录：
+ `name` – 复制插槽的名称。
+ `active_pid` – walsender 进程的 ID。
+ `cache_hit` – 自上次重置以来的 wal 缓存命中总数。
+ `cache_miss` – 自上次重置以来的 wal 缓存未命中总数。
+ `blks_read` – wal 缓存读取请求的总数。
+ `hit_rate` – WAL 缓存命中率（cache\$1hit/blks\$1read）。
+ `last_reset_timestamp` – 上次重置计数器的时间。
## 使用说明
此函数可用于以下 Aurora PostgreSQL 版本。
+ 15.2 及所有更高版本
+ 14.7 及更高版本
+ 13.8 及更高版本
+ 12.12 及更高版本
+ 11.17 及更高版本
## 示例
以下示例显示了两个仅具有一个活动的 `aurora_stat_logical_wal_cache` 函数的复制插槽。
```
=> SELECT *
FROM aurora_stat_logical_wal_cache();
name | active_pid | cache_hit | cache_miss | blks_read | hit_rate | last_reset_timestamp
------------+------------+-----------+------------+-----------+----------+-------------------------------
test_slot1 | 79183 | 24 | 0 | 24 | 100.00% | 2022-08-05 17:39:56.830635+00
test_slot2 | | 1 | 0 | 1 | 100.00% | 2022-08-05 17:34:04.036795+00
(2 rows)
```
# aurora\$1stat\$1memctx\$1usage
报告每个 PostgreSQL 进程的内存上下文使用情况。
## 语法
```
aurora_stat_memctx_usage()
```
## 参数
无
## 返回类型
包含以下列的 SETOF 记录：
+ `pid` – 进程的 ID。
+ `name` – 内存上下文的名称。
+ `allocated` – 内存上下文从底层内存子系统获得的字节数。
+ `used` – 提交给内存上下文客户端的字节数。
+ `instances` – 当前存在的此类上下文的计数。
## 使用说明
此函数显示每个 PostgreSQL 进程的内存上下文使用情况。有些进程标为 `anonymous`。这些进程不会被公开，因为其中包含受限制的关键字。
从以下 Aurora PostgreSQL 版本开始提供此函数：
+ 15.3 及更高的 15 版本
+ 14.8 及更高的 14 版本
+ 13.11 及更高的 13 版本
+ 12.15 及更高的 12 版本
+ 11.20 及更高的 11 版本
## 示例
以下示例显示了调用 `aurora_stat_memctx_usage` 函数的结果。
```
=> SELECT *
FROM aurora_stat_memctx_usage();
pid| name | allocated | used | instances
-------+---------------------------------+-----------+---------+-----------
123864 | Miscellaneous | 19520 | 15064 | 3
123864 | Aurora File Context | 8192 | 616 | 1
123864 | Aurora WAL Context | 8192 | 296 | 1
123864 | CacheMemoryContext | 524288 | 422600 | 1
123864 | Catalog tuple context | 16384 | 13736 | 1
123864 | ExecutorState | 32832 | 28304 | 1
123864 | ExprContext | 8192 | 1720 | 1
123864 | GWAL record construction | 1024 | 832 | 1
123864 | MdSmgr | 8192 | 296 | 1
123864 | MessageContext | 532480 | 353832 | 1
123864 | PortalHeapMemory | 1024 | 488 | 1
123864 | PortalMemory | 8192 | 576 | 1
123864 | printtup | 8192 | 296 | 1
123864 | RelCache hash table entries | 8192 | 8152 | 1
123864 | RowDescriptionContext | 8192 | 1344 | 1
123864 | smgr relation context | 8192 | 296 | 1
123864 | Table function arguments | 8192 | 352 | 1
123864 | TopTransactionContext | 8192 | 632 | 1
123864 | TransactionAbortContext | 32768 | 296 | 1
123864 | WAL record construction | 50216 | 43904 | 1
123864 | hash table | 65536 | 52744 | 6
123864 | Relation metadata | 191488 | 124240 | 87
104992 | Miscellaneous | 9280 | 7728 | 3
104992 | Aurora File Context | 8192 | 376 | 1
104992 | Aurora WAL Context | 8192 | 296 | 1
104992 ||Autovacuum Launcher | 8192 | 296 | 1
104992 | Autovacuum database list | 16384 | 744 | 2
104992 | CacheMemoryContext | 262144 | 140288 | 1
104992 | Catalog tuple context | 8192 | 296 | 1
104992 | GWAL record construction | 1024 | 832 | 1
104992 | MdSmgr | 8192 | 296 | 1
104992 | PortalMemory | 8192 | 296 | 1
104992 | RelCache hash table entries | 8192 | 296 | 1
104992 | smgr relation context | 8192 | 296 | 1
104992 | Autovacuum start worker (tmp) | 8192 | 296 | 1
104992 | TopTransactionContext | 16384 | 592 | 2
104992 | TransactionAbortContext | 32768 | 296 | 1
104992 | WAL record construction | 50216 | 43904 | 1
104992 | hash table | 49152 | 34024 | 4
(39 rows)
```
一些受限制的关键字将被隐藏，输出将如下所示：
```
postgres=>SELECT *
FROM aurora_stat_memctx_usage();
pid| name | allocated | used | instances
-------+---------------------------------+-----------+---------+-----------
5482 | anonymous | 8192 | 456 | 1
5482 | anonymous | 8192 | 296 | 1
```
# aurora\$1stat\$1optimized\$1reads\$1cache
此函数显示分层缓存统计信息。
## 语法
```
aurora_stat_optimized_reads_cache()
```
## 参数
无
## 返回类型
包含以下列的 SETOF 记录：
+ `total_size` – 优化型读取缓存总大小。
+ `used_size` – 优化型读取缓存中使用的页面大小。
## 使用说明
此函数可用于以下 Aurora PostgreSQL 版本：
+ 15.4 及更高的 15 版本
+ 14.9 及更高的 14 版本
## 示例
下面的示例显示了 r6gd.8xlarge 实例上的输出：
```
=> select pg_size_pretty(total_size) as total_size, pg_size_pretty(used_size)
as used_size from aurora_stat_optimized_reads_cache();
total_size | used_size
-----------+-----------
1054 GB | 975 GB
```
# aurora\$1stat\$1plans
为每个跟踪的执行计划返回一行。
## 语法
```
aurora_stat_plans(
showtext
)
```
## 参数
+ showtext：显示查询和计划文本。有效值为 NULL、true 或 false。True 将显示查询和计划文本。
## 返回类型
为每个跟踪的计划返回一行，其中包含来自 `aurora_stat_statements` 的所有列和以下附加列。
+ planid：计划标识符
+ explain\$1plan：解释计划文本
+ plan\$1type：
+ `no plan`：未捕获到任何计划
+ `estimate`：使用估计成本捕获的计划
+ `actual`：使用 EXPLAIN ANALYZE 捕获的计划
+ plan\$1captured\$1time：上次捕获计划的时间
## 使用说明
必须启用 `aurora_compute_plan_id` 并且 `pg_stat_statements` 必须处于 `shared_preload_libraries` 状态才能跟踪计划。
可用计划的数量由在 `pg_stat_statements.max` 参数中设置的值控制。启用 `aurora_compute_plan_id` 后，您可以在 `aurora_stat_plans` 中跟踪不超过此指定值的计划。
Aurora PostgreSQL 版本 14.10、15.5 以及所有其它更高版本都提供了此函数。
## 示例
在下面的示例中，将捕获用于查询标识符 5471422286312252535 的两个计划，并通过 planid 跟踪语句统计数据。
```
db1=# select calls, total_exec_time, planid, plan_captured_time, explain_plan
db1-# from aurora_stat_plans(true)
db1-# where queryid = '-5471422286312252535'
calls | total_exec_time | planid | plan_captured_time | explain_plan
---------+--------------------+-------------+-------------------------------+------------------------------------------------------------------
1532632 | 3209846.097107853 | 1602979607 | 2023-10-31 03:27:16.925497+00 | Update on pgbench_branches +
| | | | -> Bitmap Heap Scan on pgbench_branches +
| | | | Recheck Cond: (bid = 76) +
| | | | -> Bitmap Index Scan on pgbench_branches_pkey +
| | | | Index Cond: (bid = 76)
61365 | 124078.18012200127 | -2054628807 | 2023-10-31 03:20:09.85429+00 | Update on pgbench_branches +
| | | | -> Index Scan using pgbench_branches_pkey on pgbench_branches+
| | | | Index Cond: (bid = 17)
```
# aurora\$1stat\$1reset\$1wal\$1cache
重置逻辑 wal 缓存的计数器。
## 语法
重置特定插槽
```
SELECT * FROM aurora_stat_reset_wal_cache('slot_name')
```
重置所有插槽
```
SELECT * FROM aurora_stat_reset_wal_cache(NULL)
```
## 参数
`NULL` 或 `slot_name`
## 返回类型
状态消息，文本字符串
+ 重置逻辑 wal 缓存计数器 – 成功消息。函数成功时将返回此文本。
+ 未找到复制插槽。请重试。– 失败消息。当函数不成功时，将返回此文本。
## 使用说明
此函数可用于以下版本。
+ Aurora PostgreSQL 14.5 及更高版本
+ Aurora PostgreSQL 版本 13.8 及更高版本
+ Aurora PostgreSQL 版本 12.12 及更高版本
+ Aurora PostgreSQL 版本 11.17 及更高版本
## 示例
以下示例使用 `aurora_stat_reset_wal_cache` 函数重置名为 `test_results` 的插槽，然后尝试重置不存在的插槽。
```
=> SELECT *
FROM aurora_stat_reset_wal_cache('test_slot');
aurora_stat_reset_wal_cache
--------------------------------------
Reset the logical wal cache counter.
(1 row)
=> SELECT *
FROM aurora_stat_reset_wal_cache('slot-not-exist');
aurora_stat_reset_wal_cache
-----------------------------------------------
Replication slot not found. Please try again.
(1 row)
```
# aurora\$1stat\$1resource\$1usage
报告所有 Aurora PostgreSQL 后端进程的实时资源利用率，其中包括后端资源指标和 CPU 使用率。
## 语法
```
aurora_stat_resource_usage()
```
## 参数
无
## 返回类型
带有以下各列的 SETOF 记录：
+ pid：进程标识符
+ allocated\$1memory：进程分配的内存总量（以字节为单位）
+ used\$1memory：进程实际使用的内存（以字节为单位）
+ cpu\$1usage\$1percent：进程的 CPU 使用率百分比
## 使用说明
此函数显示每个 Aurora PostgreSQL 后端进程的后端资源使用情况。
从以下 Aurora PostgreSQL 版本开始提供此函数：
+ Aurora PostgreSQL 17.5 及更高的 17 版本
+ Aurora PostgreSQL 16.9 及更高的 16 版本
+ Aurora PostgreSQL 15.13 及更高的 15 版本
+ Aurora PostgreSQL 14.18 及更高的 14 版本
+ Aurora PostgreSQL 13.21 及更高的 13 版本
## 示例
下面的示例显示 `aurora_stat_resource_usage` 函数的输出。
```
=> select * from aurora_stat_resource_usage();
pid | allocated_memory | used_memory | cpu_usage_percent
------+------------------+-------------+-----------------------
666 | 1074032 | 333544 | 0.00729274882897963
667 | 787312 | 287360 | 0.0029263928146372746
668 | 3076776 | 1563488 | 0.006013116835953961
684 | 803744 | 307480 | 0.002226855426881142
2401 | 1232992 | 943144 | 0
647 | 8000 | 944 | 0.48853387812429855
659 | 319344 | 243000 | 0.0004135602076683591
663 | 262000 | 185736 | 0.008181301476644002
664 | 9024 | 1216 | 0.10992313082653653
(9 rows)
```
# aurora\$1stat\$1statements
显示所有 `pg_stat_statements` 列并在最后添加更多列。
## 语法
```
aurora_stat_statements(showtext boolean)
```
## 参数
*showtext boolean*
## 返回类型
包含所有 `pg_stat_statements` 列和以下附加列的 SETOF 记录。有关 `pg_stat_statements` 列的更多信息，请参阅 [https://www.postgresql.org/docs/current/pgstatstatements.html](https://www.postgresql.org/docs/current/pgstatstatements.html)。
您可以使用 `pg_stat_statements_reset()` 重置此函数的统计信息。
+ `storage_blks_read` – 从该语句的 aurora 存储中读取的共享块总数。
+ `orcache_blks_hit` – 此语句中优化型读取缓存命中总数。
+ `storage_blk_read_time` – 如果已启用 `track_io_timing`，它将跟踪语句从 aurora 存储中读取共享块所花费的总时间（以毫秒为单位），否则该值为零。有关更多信息，请参阅 [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING)。
+ `local_blk_read_time` – 如果已启用 `track_io_timing`，它将跟踪语句读取本地块所花费的总时间（以毫秒为单位），否则该值为零。有关更多信息，请参阅 [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING)。
+ `orcache_blk_read_time` – 如果已启用 `track_io_timing`，它将跟踪语句从优化型读取缓存中读取共享块所花费的总时间（以毫秒为单位），否则该值为零。有关更多信息，请参阅 [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING)。
+ `total_plan_peakmem` – 对此语句的所有调用在计划阶段的峰值内存值的总和。要查看语句在计划期间的平均峰值内存，请将该值除以调用数。
+ `min_plan_peakmem` – 在计划期间，在对此语句的所有调用中看到的最小峰值内存值。
+ `max_plan_peakmem` – 在计划期间，在对此语句的所有调用中看到的最大峰值内存值。
+ `total_exec_peakmem` – 对此语句的所有调用在执行阶段的峰值内存值的总和。要查看语句在执行期间的平均峰值内存，请将该值除以调用数。
+ `min_exec_peakmem` – 在对此语句的所有调用的执行期间，出现的最小峰值内存值，以字节为单位。
+ `max_exec_peakmem` – 在对此语句的所有调用的执行期间，出现的最大峰值内存值，以字节为单位。
**注意**
仅当设置 `pg_stat_statements.track_planning` 为开启时，`total_plan_peakmen`、`min_plan_peakmem` 和 `max_plan_peakmem` 才会受到监控。
## 使用说明
要使用 aurora\$1stat\$1statements() 函数，必须在 `shared_preload_libraries` 参数中包含 `pg_stat_statements` 扩展。
此函数可用于以下 Aurora PostgreSQL 版本：
+ 15.4 及更高的 15 版本
+ 14.9 及更高的 14 版本
以下版本中提供了显示峰值内存的列：
+ 16.3 及更高版本
+ 15.7 及更高版本
+ 14.12 及更高版本
## 示例
以下示例显示了它如何携带所有 pg\$1stat\$1statements 列并在最后附加 11 个新列：
```
=> select * from aurora_stat_statements(true) where query like 'with window_max%';
-[ RECORD 1 ]----------+------------------------------------------------------------------------------------------------
userid | 16409
dbid | 5
toplevel | t
queryid | -8347523682669847482
query | with window_max as (select custid, max(scratch) over (order by scratch rows between $1 preceding
and $2 following) wmax from ts) select sum(wmax), max(custid) from window_max
plans | 0
total_plan_time | 0
min_plan_time | 0
max_plan_time | 0
mean_plan_time | 0
stddev_plan_time | 0
calls | 4
total_exec_time | 254.105121
min_exec_time | 57.503164000000005
max_exec_time | 68.687418
mean_exec_time | 63.52628025
stddev_exec_time | 5.150765359979643
rows | 4
shared_blks_hit | 200192
shared_blks_read | 0
shared_blks_dirtied | 0
shared_blks_written | 0
local_blks_hit | 0
local_blks_read | 0
local_blks_dirtied | 0
local_blks_written | 0
temp_blks_read | 0
temp_blks_written | 0
blk_read_time | 0
blk_write_time | 0
temp_blk_read_time | 0
temp_blk_write_time | 0
wal_records | 0
wal_fpi | 0
wal_bytes | 0
jit_functions | 0
jit_generation_time | 0
jit_inlining_count | 0
jit_inlining_time | 0
jit_optimization_count | 0
jit_optimization_time | 0
jit_emission_count | 0
jit_emission_time | 0
storage_blks_read | 0
orcache_blks_hit | 0
storage_blk_read_time | 0
local_blk_read_time | 0
orcache_blk_read_time | 0
total_plan_peakmem | 0
min_plan_peakmem | 0
max_plan_peakmem | 0
total_exec_peakmem | 6356224
min_exec_peakmem | 1589056
max_exec_peakmem | 1589056
```
# aurora\$1stat\$1system\$1waits
报告 Aurora PostgreSQL 数据库实例的等待事件信息。
## 语法
```
aurora_stat_system_waits()
```
## 参数
无
## 返回类型
SETOF 记录
## 使用说明
此函数返回由您当前连接的数据库实例生成的每个等待事件的累积等待次数和累积等待时间。
返回的记录集中包含以下字段：
+ `type_id` – 等待事件类型的 ID。
+ `event_id` – 等待事件的 ID。
+ `waits` – 等待事件发生的次数。
+ `wait_time` – 等待此事件所花费的总时间（以微秒为单位）。
当数据库实例重新启动时，此函数返回的统计信息将重置。
## 示例
以下示例显示了调用 `aurora_stat_system_waits` 函数的结果。
```
=> SELECT *
FROM aurora_stat_system_waits();
type_id | event_id | waits | wait_time
---------+-----------+-----------+--------------
1 | 16777219 | 11 | 12864
1 | 16777220 | 501 | 174473
1 | 16777270 | 53171 | 23641847
1 | 16777271 | 23 | 319668
1 | 16777274 | 60 | 12759
.
.
.
10 | 167772231 | 204596 | 790945212
10 | 167772232 | 2 | 47729
10 | 167772234 | 1 | 888
10 | 167772235 | 2 | 64
```
以下示例显示了如何将此函数与 `aurora_stat_wait_event` 和 `aurora_stat_wait_type` 一起使用并产生更具可读性的结果。
```
=> SELECT type_name,
event_name,
waits,
wait_time
FROM aurora_stat_system_waits()
NATURAL JOIN aurora_stat_wait_event()
NATURAL JOIN aurora_stat_wait_type();
type_name | event_name | waits | wait_time
-----------+------------------------+----------+--------------
LWLock | XidGenLock | 11 | 12864
LWLock | ProcArrayLock | 501 | 174473
LWLock | buffer_content | 53171 | 23641847
LWLock | rdsutils | 2 | 12764
Lock | tuple | 75686 | 2033956052
Lock | transactionid | 1765147 | 47267583409
Activity | AutoVacuumMain | 136868 | 56305604538
Activity | BgWriterHibernate | 7486 | 55266949471
Activity | BgWriterMain | 7487 | 1508909964
.
.
.
IO | SLRURead | 3 | 11756
IO | WALWrite | 52544463 | 388850428
IO | XactSync | 187073 | 597041642
IO | ClogRead | 2 | 47729
IO | OutboundCtrlRead | 1 | 888
IO | OutboundCtrlWrite | 2 | 64
```
# aurora\$1stat\$1wait\$1event
列出 Aurora PostgreSQL 的所有支持等待事件。有关 Aurora PostgreSQL 等待事件的信息，请参阅 [Amazon Aurora PostgreSQL 等待事件](AuroraPostgreSQL.Reference.Waitevents.md)。
## 语法
```
aurora_stat_wait_event()
```
## 参数
无
## 返回类型
包含以下列的 SETOF 记录：
+ type\$1id – 等待事件类型的 ID。
+ event\$1id – 等待事件的 ID。
+ type\$1name – 等待类型名称
+ event\$1name – 等待事件名称
## 使用说明
要查看具有事件类型而不是 ID 的事件名称，请将此函数与其他函数（如 `aurora_stat_wait_type` 和 `aurora_stat_system_waits`）一起使用。此函数返回的等待事件名称与 `aurora_wait_report` 函数返回的事件名称相同。
## 示例
以下示例显示了调用 `aurora_stat_wait_event` 函数的结果。
```
=> SELECT *
FROM aurora_stat_wait_event();
type_id | event_id | event_name
---------+-----------+-------------------------------------------
1 | 16777216 |
1 | 16777217 | ShmemIndexLock
1 | 16777218 | OidGenLock
1 | 16777219 | XidGenLock
.
.
.
9 | 150994945 | PgSleep
9 | 150994946 | RecoveryApplyDelay
10 | 167772160 | BufFileRead
10 | 167772161 | BufFileWrite
10 | 167772162 | ControlFileRead
.
.
.
10 | 167772226 | WALInitWrite
10 | 167772227 | WALRead
10 | 167772228 | WALSync
10 | 167772229 | WALSyncMethodAssign
10 | 167772230 | WALWrite
10 | 167772231 | XactSync
.
.
.
11 | 184549377 | LsnAllocate
```
以下示例连接 `aurora_stat_wait_type` 和 `aurora_stat_wait_event` 来返回类型名称和事件名称以提高可读性。
```
=> SELECT *
FROM aurora_stat_wait_type() t
JOIN aurora_stat_wait_event() e
ON t.type_id = e.type_id;
type_id | type_name | type_id | event_id | event_name
---------+-----------+---------+-----------+-------------------------------------------
1 | LWLock | 1 | 16777216 |
1 | LWLock | 1 | 16777217 | ShmemIndexLock
1 | LWLock | 1 | 16777218 | OidGenLock
1 | LWLock | 1 | 16777219 | XidGenLock
1 | LWLock | 1 | 16777220 | ProcArrayLock
.
.
.
3 | Lock | 3 | 50331648 | relation
3 | Lock | 3 | 50331649 | extend
3 | Lock | 3 | 50331650 | page
3 | Lock | 3 | 50331651 | tuple
.
.
.
10 | IO | 10 | 167772214 | TimelineHistorySync
10 | IO | 10 | 167772215 | TimelineHistoryWrite
10 | IO | 10 | 167772216 | TwophaseFileRead
10 | IO | 10 | 167772217 | TwophaseFileSync
.
.
.
11 | LSN | 11 | 184549376 | LsnDurable
```
# aurora\$1stat\$1wait\$1type
列出 Aurora PostgreSQL 的所有支持等待类型。
## 语法
```
aurora_stat_wait_type()
```
## 参数
无
## 返回类型
包含以下列的 SETOF 记录：
+ type\$1id – 等待事件类型的 ID。
+ type\$1name – 等待类型名称。
## 使用说明
要查看具有等待事件类型而不是 ID 的等待事件名称，请将此函数与其他函数（如 `aurora_stat_wait_event` 和 `aurora_stat_system_waits`）一起使用。此函数返回的等待类型名称与 `aurora_wait_report` 函数返回的事件名称相同。
## 示例
以下示例显示了调用 `aurora_stat_wait_type` 函数的结果。
```
=> SELECT *
FROM aurora_stat_wait_type();
type_id | type_name
---------+-----------
1 | LWLock
3 | Lock
4 | BufferPin
5 | Activity
6 | Client
7 | Extension
8 | IPC
9 | Timeout
10 | IO
11 | LSN
```
# aurora\$1version
返回 Amazon Aurora PostgreSQL 兼容版本号的字符串值。
## 语法
```
aurora_version()
```
## 参数
无
## 返回类型
CHAR 或 VARCHAR 字符串
## 使用说明
此函数显示 Amazon Aurora PostgreSQL 兼容版数据库引擎的版本。版本号以字符串形式返回，格式为 *major*.*minor*.*patch*。有关 Aurora PostgreSQL 版本号的更多信息，请参阅[Aurora 版本号](AuroraPostgreSQL.Updates.md#AuroraPostgreSQL.Updates.Versions.AuroraNumber)。
您可以通过设置 Aurora PostgreSQL 数据库集群的维护时段来选择何时应用次要版本升级。要了解如何操作，请参阅[维护Amazon Aurora 数据库集群](USER_UpgradeDBInstance.Maintenance.md)。
从发布的 Aurora PostgreSQL 版本 13.3、12.8、11.13、10.18 开始至这以后发布的所有更高版本，Aurora 版本号都与 PostgreSQL 版本号保持一致。有关所有 Aurora PostgreSQL 版本的更多信息，请参阅《Aurora PostgreSQL 发布说明》中的 [Amazon Aurora PostgreSQL 更新](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Updates.html)。
## 示例
以下示例显示在运行 [PostgreSQL 12.7、Aurora PostgreSQL 版本 4.2](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Updates.html#AuroraPostgreSQL.Updates.20180305.42) 的 Aurora PostgreSQL 数据库集群上调用 `aurora_version` 函数，然后在运行 [Aurora PostgreSQL 版本 13.3](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Updates.html#AuroraPostgreSQL.Updates.20180305.133X) 的集群上运行相同函数的结果。
```
=> SELECT * FROM aurora_version();
aurora_version
----------------
4.2.2
SELECT * FROM aurora_version();
aurora_version
----------------
13.3.0
```
此示例说明如何将函数与各种选项结合使用，以获取有关 Aurora PostgreSQL 版本的更多详细信息。此示例具有与 PostgreSQL 版本号不同的 Aurora 版本号。
```
=> SHOW SERVER_VERSION;
server_version
----------------
12.7
(1 row)
=> SELECT * FROM aurora_version();
aurora_version
----------------
4.2.2
(1 row)
=> SELECT current_setting('server_version') AS "PostgreSQL Compatiblility";
PostgreSQL Compatiblility
---------------------------
12.7
(1 row)
=> SELECT version() AS "PostgreSQL Compatiblility Full String";
PostgreSQL Compatiblility Full String
-------------------------------------------------------------------------------------------------------------
PostgreSQL 12.7 on aarch64-unknown-linux-gnu, compiled by aarch64-unknown-linux-gnu-gcc (GCC) 7.4.0, 64-bit
(1 row)
=> SELECT 'Aurora: '
|| aurora_version()
|| ' Compatible with PostgreSQL: '
|| current_setting('server_version') AS "Instance Version";
Instance Version
------------------------------------------------
Aurora: 4.2.2 Compatible with PostgreSQL: 12.7
(1 row)
```
下一个示例使用具有与上一个示例相同选项的函数。此示例不具有与 PostgreSQL 版本号不同的 Aurora 版本号。
```
=> SHOW SERVER_VERSION;
server_version
----------------
13.3
=> SELECT * FROM aurora_version();
aurora_version
----------------
13.3.0
=> SELECT current_setting('server_version') AS "PostgreSQL Compatiblility";
PostgreSQL Compatiblility
---------------------------
13.3
=> SELECT version() AS "PostgreSQL Compatiblility Full String";
PostgreSQL Compatiblility Full String
-------------------------------------------------------------------------------------------------
PostgreSQL 13.3 on x86_64-pc-linux-gnu, compiled by x86_64-pc-linux-gnu-gcc (GCC) 7.4.0, 64-bit
=> SELECT 'Aurora: '
|| aurora_version()
|| ' Compatible with PostgreSQL: '
|| current_setting('server_version') AS "Instance Version";
Instance Version
-------------------------------------------------------
Aurora: 13.3.0 Compatible with PostgreSQL: 13.3
```
# aurora\$1volume\$1logical\$1start\$1lsn
返回一个日志序列号（LSN），此序列号用于标识 Aurora 集群卷的逻辑预写日志（WAL）流中记录的开头。
## 语法
```
aurora_volume_logical_start_lsn()
```
## 参数
无
## 返回类型
`pg_lsn`
## 使用说明
此函数标识给定 Aurora 集群卷的逻辑 WAL 流中记录的开头。在使用逻辑复制和 Aurora 快速克隆执行主要版本升级时，您可以使用此函数来确定用于拍摄快照或制作数据库克隆的 LSN。然后，您可以使用逻辑复制来持续流式传输 LSN 之后记录的较新数据，并将更改从发布者同步到订阅用户。
有关使用逻辑复制进行主要版本升级的更多信息，请参阅[使用逻辑复制对 Aurora PostgreSQL 执行主要版本升级](AuroraPostgreSQL.MajorVersionUpgrade.md)。
此函数可用于以下 Aurora PostgreSQL 版本：
+ 15.2 及更高的 15 版本
+ 14.3 及更高的 14 版本
+ 13.6 及更高的 13 版本
+ 12.10 及更高的 12 版本
+ 11.15 及更高的 11 版本
+ 10.20 及更高的 10 版本
## 示例
您可以使用以下查询获取日志序列号（LSN）：
```
postgres=> SELECT aurora_volume_logical_start_lsn();
aurora_volume_logical_start_lsn
---------------
0/402E2F0
(1 row)
```
# aurora\$1wait\$1report
此函数显示一段时间内的等待事件活动。
## 语法
```
aurora_wait_report([time])
```
## 参数
*时间（可选）*
以秒为单位的时间。默认为 10 秒。
## 返回类型
包含以下列的 SETOF 记录：
+ type\$1name – 等待类型名称
+ event\$1name – 等待事件名称
+ 等待 – 等待次数
+ wait\$1time – 以毫秒为单位的等待时间
+ ms\$1per\$1wait – 按等待次数计算的平均毫秒数
+ waits\$1per\$1xact – 按一个事务数计算的平均等待次数
+ ms\$1per\$1xact – 按事务数计算的平均毫秒数
## 使用说明
此函数从与 PostgreSQL 9.6.6 及更高版本兼容的 Aurora PostgreSQL 版本 1.1 开始提供。
要使用此函数，您首先需要创建 Aurora PostgreSQL `aurora_stat_utils` 扩展，如下所示：
```
=> CREATE extension aurora_stat_utils;
CREATE EXTENSION
```
有关可用的 urora PostgreSQL 扩展版本的更多信息，请参阅《Aurora PostgreSQL 发布说明》中的[适用于 Amazon Aurora PostgreSQL 的扩展版本](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Extensions.html)。
此函数通过将 aurora\$1stat\$1system\$1waits() 函数和 pg\$1stat\$1database PostgreSQL 统计信息视图中的两个统计信息数据快照进行比较来计算实例级等待事件。
有关 `aurora_stat_system_waits()` 和 `pg_stat_database` 的更多信息，请参阅 *PostgreSQL 文档*中的[统计信息收集器](https://www.postgresql.org/docs/current/monitoring-stats.html#PG-STAT-DATABASE-VIEW)。
运行时，此函数会拍摄初始快照，等待指定的秒数，然后再拍摄第二个快照。此函数会比较两个快照并返回差异。此差异代表实例在该时间间隔内的活动。
在写入器实例上，此函数还显示已提交的事务数和 TPS（每秒事务数）。此函数返回实例级别的信息，包括实例上的所有数据库。
## 示例
此示例说明如何创建 aurora\$1stat\$1utils 扩展，以便能够使用 aurora\$1wait\$1report 函数。
```
=> CREATE extension aurora_stat_utils;
CREATE EXTENSION
```
此示例说明如何检查 10 秒的等待报告。
```
=> SELECT *
FROM aurora_wait_report();
NOTICE: committed 34 transactions in 10 seconds (tps 3)
type_name | event_name | waits | wait_time | ms_per_wait | waits_per_xact | ms_per_xact
-----------+-------------------+-------+-----------+-------------+----------------+-------------
Client | ClientRead | 26 | 30003.00 | 1153.961 | 0.76 | 882.441
Activity | WalWriterMain | 50 | 10051.32 | 201.026 | 1.47 | 295.627
Timeout | PgSleep | 1 | 10049.52 | 10049.516 | 0.03 | 295.574
Activity | BgWriterHibernate | 1 | 10048.15 | 10048.153 | 0.03 | 295.534
Activity | AutoVacuumMain | 18 | 9941.66 | 552.314 | 0.53 | 292.402
Activity | BgWriterMain | 1 | 201.09 | 201.085 | 0.03 | 5.914
IO | XactSync | 15 | 25.34 | 1.690 | 0.44 | 0.745
IO | RelationMapRead | 12 | 0.54 | 0.045 | 0.35 | 0.016
IO | WALWrite | 84 | 0.21 | 0.002 | 2.47 | 0.006
IO | DataFileExtend | 1 | 0.02 | 0.018 | 0.03 | 0.001
```
此示例说明如何检查 60 秒的等待报告。
```
=> SELECT *
FROM aurora_wait_report(60);
NOTICE: committed 1544 transactions in 60 seconds (tps 25)
type_name | event_name | waits | wait_time | ms_per_wait | waits_per_xact | ms_per_xact
-----------+------------------------+---------+-----------+-------------+----------------+-------------
Lock | transactionid | 6422 | 477000.53 | 74.276 | 4.16 | 308.938
Client | ClientRead | 8265 | 270752.99 | 32.759 | 5.35 | 175.358
Activity | CheckpointerMain | 1 | 60100.25 | 60100.246 | 0.00 | 38.925
Timeout | PgSleep | 1 | 60098.49 | 60098.493 | 0.00 | 38.924
Activity | WalWriterMain | 296 | 60010.99 | 202.740 | 0.19 | 38.867
Activity | AutoVacuumMain | 107 | 59827.84 | 559.139 | 0.07 | 38.749
Activity | BgWriterMain | 290 | 58821.83 | 202.834 | 0.19 | 38.097
IO | XactSync | 1295 | 55220.13 | 42.641 | 0.84 | 35.764
IO | WALWrite | 6602259 | 47810.94 | 0.007 | 4276.07 | 30.966
Lock | tuple | 473 | 29880.67 | 63.173 | 0.31 | 19.353
LWLock | buffer_mapping | 142 | 3540.13 | 24.930 | 0.09 | 2.293
Activity | BgWriterHibernate | 290 | 1124.15 | 3.876 | 0.19 | 0.728
IO | BufFileRead | 7615 | 618.45 | 0.081 | 4.93 | 0.401
LWLock | buffer_content | 73 | 345.93 | 4.739 | 0.05 | 0.224
LWLock | lock_manager | 62 | 191.44 | 3.088 | 0.04 | 0.124
IO | RelationMapRead | 72 | 5.16 | 0.072 | 0.05 | 0.003
LWLock | ProcArrayLock | 1 | 2.01 | 2.008 | 0.00 | 0.001
IO | ControlFileWriteUpdate | 2 | 0.03 | 0.013 | 0.00 | 0.000
IO | DataFileExtend | 1 | 0.02 | 0.018 | 0.00 | 0.000
IO | ControlFileSyncUpdate | 1 | 0.00 | 0.000 | 0.00 | 0.000
```
# Amazon Aurora PostgreSQL 参数
您可以使用数据库参数组中的参数按照与管理 Amazon RDS 数据库实例相同的方法管理 Amazon Aurora 数据库集群。但是，Amazon Aurora 与 Amazon RDS 的不同之处在于，Aurora 数据库集群有多个数据库实例。您用于管理 Amazon Aurora 数据库集群的一些参数适用于整个集群，而另一些参数仅适用于数据库集群中的给定数据库实例，如下所示：
+ **DB cluster parameter group**（数据库集群参数组）：数据库集群参数组包含应用于整个 Aurora 数据库集群的引擎配置参数集。例如，集群缓存管理是由 `apg_ccm_enabled` 参数控制的一项 Aurora 数据库集群特征，该参数是数据库集群参数组的一部分。数据库集群参数组还包含组成集群的数据库实例的数据库参数组默认设置。
+ **DB parameter group**（数据库参数组）：数据库参数组是应用于相应引擎类型的特定数据库实例的引擎配置值集。PostgreSQL 数据库引擎的数据库参数组由 RDS for PostgreSQL 数据库实例和 Aurora PostgreSQL 数据库集群使用。这些配置设置适用于在 Aurora 集群内的数据库实例之间可能不同的属性，如内存缓冲区的大小。
您可以在数据库集群参数组中管理集群级参数。您可以在数据库参数组中管理实例级参数。您可以使用 Amazon RDS 控制台、AWS CLI 或 Amazon RDS API 管理参数。可以使用单独的命令管理集群级参数和实例级参数。
+ 要管理数据库集群参数组中的集群级参数，可以使用 [modify-db-cluster-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster-parameter-group.html) AWS CLI 命令。
+ 要为数据库集群中数据库实例管理数据库参数组中的实例级参数，可以使用 [modify-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-parameter-group.html) AWS CLI 命令。
要了解有关 AWS CLI 的更多信息，请参阅《AWS Command Line Interface 用户指南**》中的[使用 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-using.html)。
有关参数组的更多信息，请参阅 [Amazon Aurora 的参数组](USER_WorkingWithParamGroups.md)。
## 查看 Aurora PostgreSQL 数据库集群和数据库参数
您可以在 AWS 管理控制台 中查看 RDS for PostgreSQL 数据库实例和 Aurora PostgreSQL 数据库集群的所有可用默认参数组。各 AWS 区域的所有数据库引擎和数据库集群类型及版本的默认参数组均已列出。同时，所有自定义参数组也已列出。
您还可以使用 AWS CLI 或 Amazon RDS API 列出数据库集群参数组和数据库参数组中包含的参数，无需在 AWS 管理控制台 中查看。例如，要列出数据库集群参数组中的参数，可以使用 [describe-db-cluster-parameters](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-cluster-parameters.html) AWS CLI 命令，如下所示：
```
aws rds describe-db-cluster-parameters --db-cluster-parameter-group-name default.aurora-postgresql12
```
该命令将返回每个参数的详细 JSON 描述。为了减少返回的信息量，您可以使用 `--query` 选项指定所需内容。例如，可以获取 Aurora PostgreSQL 12 数据库集群默认参数组的参数名称、描述和允许值，如下所示：
对于 Linux、macOS 或 Unix：
```
aws rds describe-db-cluster-parameters --db-cluster-parameter-group-name default.aurora-postgresql12 \
--query 'Parameters[].[{ParameterName:ParameterName,Description:Description,ApplyType:ApplyType,AllowedValues:AllowedValues}]'
```
对于：Windows
```
aws rds describe-db-cluster-parameters --db-cluster-parameter-group-name default.aurora-postgresql12 ^
--query "Parameters[].[{ParameterName:ParameterName,Description:Description,ApplyType:ApplyType,AllowedValues:AllowedValues}]"
```
Aurora 数据库集群参数组包括数据库实例参数组和给定 Aurora 数据库引擎的默认值。您可以使用 [describe-db-parameters](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-parameters.html) AWS CLI 命令从相同的 Aurora PostgreSQL 默认参数组中获取数据库参数列表，如下所示。
对于 Linux、macOS 或 Unix：
```
aws rds describe-db-parameters --db-parameter-group-name default.aurora-postgresql12 \
--query 'Parameters[].[{ParameterName:ParameterName,Description:Description,ApplyType:ApplyType,AllowedValues:AllowedValues}]'
```
对于：Windows
```
aws rds describe-db-parameters --db-parameter-group-name default.aurora-postgresql12 ^
--query "Parameters[].[{ParameterName:ParameterName,Description:Description,ApplyType:ApplyType,AllowedValues:AllowedValues}]"
```
上述命令将返回数据库集群或数据库参数组中的参数列表，其中包括查询中指定的描述和其他详细信息。以下是示例响应。
```
[
[
{
"ParameterName": "apg_enable_batch_mode_function_execution",
"ApplyType": "dynamic",
"Description": "Enables batch-mode functions to process sets of rows at a time.",
"AllowedValues": "0,1"
}
],
[
{
"ParameterName": "apg_enable_correlated_any_transform",
"ApplyType": "dynamic",
"Description": "Enables the planner to transform correlated ANY Sublink (IN/NOT IN subquery) to JOIN when possible.",
"AllowedValues": "0,1"
}
],...
```
下表包含 Aurora PostgreSQL 版本 14 数据库集群默认参数和数据库默认参数的值。
## Aurora PostgreSQL 集群级参数
您可以使用 AWS 管理控制台、AWS CLI 或 Amazon RDS API 查看特定 Aurora PostgreSQL 版本可用的集群级参数。有关在 RDS 控制台中查看 Aurora PostgreSQL 数据库集群参数组中的参数的信息，请参阅[在 Amazon Aurora 中查看数据库集群参数组的参数值](USER_WorkingWithParamGroups.ViewingCluster.md)。
某些集群级参数并非在所有版本中都可用，有些正要弃用。有关查看特定 Aurora PostgreSQL 版本的参数的信息，请参阅[查看 Aurora PostgreSQL 数据库集群和数据库参数](#AuroraPostgreSQL.Reference.ParameterGroups-viewing-parameters)。
例如，下表列出了 Aurora PostgreSQL 版本 14 的默认数据库集群参数组中可用的参数。如果在未指定您自定义数据库参数组的情况下创建 Aurora PostgreSQL 数据库集群，则将使用所选版本的 Aurora 数据库集群默认参数组（例如 `default.aurora-postgresql14`、`default.aurora-postgresql13` 等）来创建数据库集群。
有关此相同默认数据库集群参数组的数据库实例参数的列表，请参阅 [Aurora PostgreSQL 实例级参数](#AuroraPostgreSQL.Reference.Parameters.Instance)。
| 参数名称 | 说明 | 默认值 |
| --- | --- | --- |
| ansi\$1constraint\$1trigger\$1ordering | 更改约束触发条件的触发顺序，使其与 ANSI SQL 标准兼容。 | – |
| ansi\$1force\$1foreign\$1key\$1checks | 无论操作存在的各种触发条件的上下文如何，确保级联删除和级联更新等引用操作始终会发生。 | – |
| ansi\$1qualified\$1update\$1set\$1target | 支持 UPDATE...SET 语句中的 表格和架构限定符。 | – |
| apg\$1ccm\$1enabled | 启用或禁用集群缓存管理功能。 | – |
| apg\$1enable\$1batch\$1mode\$1function\$1execution | 启用批处理模式函数，以便一次处理多行。 | – |
| apg\$1enable\$1correlated\$1any\$1transform | 让计划程序尽可能将关联的 ANY 子链接（IN/NOT IN 子查询）转换为 JOIN。 | – |
| apg\$1enable\$1function\$1migration | 让计划程序将符合条件的标量函数迁移到 FROM 子句。 | – |
| apg\$1enable\$1not\$1in\$1transform | 让计划程序尽可能将 NOT IN 子查询转换为 ANTI JOIN。 | – |
| apg\$1enable\$1remove\$1redundant\$1inner\$1joins | 让计划程序能够删除冗余的内部联接。 | – |
| apg\$1enable\$1semijoin\$1push\$1down | 让哈希联接能够使用半联接筛选条件。 | – |
| apg\$1plan\$1mgmt.capture\$1plan\$1baselines | 捕获计划基准模式。手动：为任何 SQL 语句启用计划捕获；关闭：禁用计划捕获；自动：为 pg\$1stat\$1statements 中满足资格条件的语句启用计划捕获。 | off |
| apg\$1plan\$1mgmt.max\$1databases | 设置可以使用 apg\$1plan\$1mgmt 管理查询的最大数据库数。 | 10 |
| apg\$1plan\$1mgmt.max\$1plans | 设置 apg\$1plan\$1mgmt 可以缓存的最大计划数。 | 10000 |
| apg\$1plan\$1mgmt.plan\$1retention\$1period | 自上次使用计划至自动删除计划之间的最大天数。 | 32 |
| apg\$1plan\$1mgmt.unapproved\$1plan\$1execution\$1threshold | 预估的计划总开销，低于该值则将执行未批准计划。 | 0 |
| apg\$1plan\$1mgmt.use\$1plan\$1baselines | 仅对托管式语句使用已批准计划或固定计划。 | false |
| application\$1name | 设置要在统计数据和日志中报告的应用程序名称。 | – |
| array\$1nulls | 允许在阵列中输入 NULL 元素。 | – |
| aurora\$1compute\$1plan\$1id | 可以监控查询执行计划，以检测导致当前数据库负载的执行计划，并跟踪一段时间内执行计划的性能统计信息。有关更多信息，请参阅[监控 Aurora PostgreSQL 的查询执行计划](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraPostgreSQL.Monitoring.Query.Plans.html)。 | on |
| authentication\$1timeout | (s) 设置允许完成客户端身份验证的最长时间。 | – |
| auto\$1explain.log\$1analyze | 使用 EXPLAIN ANALYZE 记录计划。 | – |
| auto\$1explain.log\$1buffers | 记录缓冲区的使用情况。 | – |
| auto\$1explain.log\$1format | 用于计划记录的 EXPLAIN 格式。 | – |
| auto\$1explain.log\$1min\$1duration | 设置如超出即记录计划的最短执行时间。 | – |
| auto\$1explain.log\$1nested\$1statements | 记录嵌套语句。 | – |
| auto\$1explain.log\$1timing | 不仅收集行数，还收集时序数据。 | – |
| auto\$1explain.log\$1triggers | 在计划中包括触发条件统计数据。 | – |
| auto\$1explain.log\$1verbose | 使用 EXPLAIN VERBOSE 记录计划。 | – |
| auto\$1explain.sample\$1rate | 待处理查询的占比。 | – |
| autovacuum | 启动 Autovacuum 子进程。 | – |
| autovacuum\$1analyze\$1scale\$1factor | 在分析之前插入、更新或删除元组的次数，以相对于 reltuple 的占比计。 | 0.05 |
| autovacuum\$1analyze\$1threshold | 在分析之前插入、更新或删除元组的最小次数。 | – |
| autovacuum\$1freeze\$1max\$1age | 对表进行 Autovacuum 以防事务 ID 重叠的期限。 | – |
| autovacuum\$1max\$1workers | 设置同时运行的 Autovacuum 工作者的最大数量。 | GREATEST(DBInstanceClassMemory/64371566592,3) |
| autovacuum\$1multixact\$1freeze\$1max\$1age | Autovacuum 表格以防止 Multixact 重叠的 Multixact 期限。 | – |
| autovacuum\$1naptime | (s) 两次 Autovacuum 运行之间的睡眠时间。 | 5 |
| autovacuum\$1vacuum\$1cost\$1delay | Autovacuum 的 Vacuum 开销延迟，以毫秒为单位（ms）。 | 5 |
| autovacuum\$1vacuum\$1cost\$1limit | Autovacuum 在小睡之前可用的真空开销量。 | GREATEST(log(DBInstanceClassMemory/21474836480)\$1600,200) |
| autovacuum\$1vacuum\$1insert\$1scale\$1factor | Vacuum 之前插入元组的次数，以相对于 reltuple 的占比计。 | – |
| autovacuum\$1vacuum\$1insert\$1threshold | 在 vacuum 之前插入元组的最小次数，-1 则表示禁用插入 vacuum。 | – |
| autovacuum\$1vacuum\$1scale\$1factor | Vacuum 之前更新或删除元组的次数，以相对于 reltuple 的占比计。 | 0.1 |
| autovacuum\$1vacuum\$1threshold | Vacuum 之前更新或删除元组的最小次数。 | – |
| autovacuum\$1work\$1mem | (kB) 设置要由每个 Autovacuum 工件进程使用的最大内存。 | GREATEST(DBInstanceClassMemory/32768,131072) |
| babelfishpg\$1tds.default\$1server\$1name | 默认 Babelfish 服务器名称 | Microsoft SQL Server |
| babelfishpg\$1tds.listen\$1addresses | 设置要监听 TDS 的主机名或 IP 地址。 | \$1 |
| babelfishpg\$1tds.port | 设置服务器监听的 TDS TCP 端口。 | 1433 |
| babelfishpg\$1tds.tds\$1debug\$1log\$1level | 设置 TDS 中的日志记录级别，0 表示禁用日志记录 | 1 |
| babelfishpg\$1tds.tds\$1default\$1numeric\$1precision | 如果引擎未指定要在 TDS 列元数据中发送的数字类型的默认精度，则设置默认精度。 | 38 |
| babelfishpg\$1tds.tds\$1default\$1numeric\$1scale | 如果引擎未指定要在 TDS 列元数据中发送的数字类型的默认小数位数，则设置默认小数位数。 | 8 |
| babelfishpg\$1tds.tds\$1default\$1packet\$1size | 设置用于所有连接的 SQL Server 客户端的默认数据包大小 | 4096 |
| babelfishpg\$1tds.tds\$1default\$1protocol\$1version | 设置用于所有连接的客户端的默认 TDS 协议版本 | DEFAULT |
| babelfishpg\$1tds.tds\$1ssl\$1crypt | 设置 SSL 加密选项 | 0 |
| babelfishpg\$1tds.tds\$1ssl\$1max\$1protocol\$1version | 设置 TDS 会话使用的最高 SSL/TLS 协议版本。 | TLSv1.2 |
| babelfishpg\$1tds.tds\$1ssl\$1min\$1protocol\$1version | 设置 TDS 会话使用的最低 SSL/TLS 协议版本。 | 在 Aurora PostgreSQL 版本 16 中，为 TLSv1.2；对于比 Aurora PostgreSQL 版本 16 更早的版本，为 TLSv1 |
| babelfishpg\$1tsql.default\$1locale | 由 CREATE COLLATION 创建的排序规则使用的默认区域设置。 | en-US |
| babelfishpg\$1tsql.migration\$1mode | 定义是否支持多个用户数据库 | 在 Aurora PostgreSQL 版本 16 中，为 multi-db；对于比 Aurora PostgreSQL 版本 16 更早的版本，为 single-db |
| babelfishpg\$1tsql.server\$1collation\$1name | 默认服务器排序规则的名称 | sql\$1latin1\$1general\$1cp1\$1ci\$1as |
| babelfishpg\$1tsql.version | 设置 @@VERSION 变量的输出 | 默认 |
| backend\$1flush\$1after | (8 kB) 先前执行的写入操作刷新到磁盘的页数。 | – |
| backslash\$1quote | 设置字符串文本中是否允许有 \$1\$1。 | – |
| backtrace\$1functions | 记录这些函数中错误的回溯。 | – |
| bytea\$1output | 设置字节的输出格式。 | – |
| check\$1function\$1bodies | 在 CREATE FUNCTION 期间检查函数体。 | – |
| client\$1connection\$1check\$1interval | 设置在运行查询时检查断开连接的时间间隔。 | – |
| client\$1encoding | 设置客户端字符集编码。 | UTF8 |
| client\$1min\$1messages | 设置发送到客户端的消息级别。 | – |
| compute\$1query\$1id | 计算查询标识符。 | 自动 |
| config\$1file | 设置服务器主配置文件。 | /rdsdbdata/config/postgresql.conf |
| constraint\$1exclusion | 使计划程序可使用约束优化查询。 | – |
| cpu\$1index\$1tuple\$1cost | 设置计划程序预估索引扫描期间处理每个索引条目的开销。 | – |
| cpu\$1operator\$1cost | 设置计划程序预估处理每个运算符或函数调用的开销。 | – |
| cpu\$1tuple\$1cost | 设置计划程序预估处理每个元组（行）的开销。 | – |
| cron.database\$1name | 设置数据库存储 pg\$1cron 元数据表 | postgres |
| cron.log\$1run | 将所有任务运行记录到 job\$1run\$1details 表中 | on |
| cron.log\$1statement | 在执行之前记录所有 cron 语句。 | off |
| cron.max\$1running\$1jobs | 可以同时运行的最大任务数。 | 5 |
| cron.use\$1background\$1workers | 启用 pg\$1cron 的背景工件 | on |
| cursor\$1tuple\$1fraction | 设置计划程序预估待检索光标行的占比。 | – |
| data\$1directory | 设置服务器数据目录。 | /rdsdbdata/db |
| datestyle | 设置日期和时间值的显示格式。 | – |
| db\$1user\$1namespace | 启用各数据库的用户名。 | – |
| deadlock\$1timeout | (ms) 设置在检查死锁之前等待锁定的时间。 | – |
| debug\$1pretty\$1print | 缩进分析树和计划树的显示内容。 | – |
| debug\$1print\$1parse | 记录每个查询的分析树。 | – |
| debug\$1print\$1plan | 记录每个查询的执行计划。 | – |
| debug\$1print\$1rewritten | 记录每个查询重写的分析树。 | – |
| default\$1statistics\$1target | 设置默认统计数据目标。 | – |
| default\$1tablespace | 设置要从中创建表和索引的默认表空间。 | – |
| default\$1toast\$1compression | 为可压缩值设置默认压缩方法。 | – |
| default\$1transaction\$1deferrable | 设置新事务的默认可延迟状态。 | – |
| default\$1transaction\$1isolation | 设置每个新事务的事务隔离级别。 | – |
| default\$1transaction\$1read\$1only | 设置新事务的默认只读状态。 | – |
| effective\$1cache\$1size | (8kB) 设置计划程序对于磁盘缓存大小的假设。 | SUM(DBInstanceClassMemory/12038,-50003) |
| effective\$1io\$1concurrency | 磁盘子系统可有效处理的并行请求数。 | – |
| enable\$1async\$1append | 使计划程序可使用异步追加计划。 | – |
| enable\$1bitmapscan | 使计划程序可使用位图扫描计划。 | – |
| enable\$1gathermerge | 使计划程序可使用收集合并计划。 | – |
| enable\$1hashagg | 使计划程序可使用哈希聚合计划。 | – |
| enable\$1hashjoin | 使计划程序可使用哈希联接计划。 | – |
| enable\$1incremental\$1sort | 使计划程序可使用增量排序步骤。 | – |
| enable\$1indexonlyscan | 使计划程序可使用仅限索引的扫描计划。 | – |
| enable\$1indexscan | 使计划程序可使用索引扫描计划。 | – |
| enable\$1material | 使计划程序可使用具体化。 | – |
| enable\$1memoize | 使计划程序可使用记忆功能 | – |
| enable\$1mergejoin | 使计划程序可使用合并联接计划。 | – |
| enable\$1nestloop | 使计划程序可使用嵌套循环的联接计划。 | – |
| enable\$1parallel\$1append | 使计划程序可使用并行追加计划。 | – |
| enable\$1parallel\$1hash | 使计划程序可使用并行哈希计划。 | – |
| enable\$1partition\$1pruning | 启用计划时和运行时分区修剪。 | – |
| enable\$1partitionwise\$1aggregate | 启用智能分区聚合和分组。 | – |
| enable\$1partitionwise\$1join | 启用智能分区联接。 | – |
| enable\$1seqscan | 使计划程序可使用顺序扫描计划。 | – |
| enable\$1sort | 使计划程序可使用显式排序步骤。 | – |
| enable\$1tidscan | 使计划程序可使用 TID 扫描计划。 | – |
| escape\$1string\$1warning | 警告在普通字符串文本中有反斜杠转义符。 | – |
| exit\$1on\$1error | 发生任何错误时终止会话。 | – |
| extra\$1float\$1digits | 设置所显示的浮点值位数。 | – |
| force\$1parallel\$1mode | 强制使用并行查询功能。 | – |
| from\$1collapse\$1limit | 设置超出其即不折叠子查询的 FROM 列表大小。 | – |
| geqo | 启用基因查询优化。 | – |
| geqo\$1effort | GEQO：用于设置其他 GEQO 参数默认值的工作负载。 | – |
| geqo\$1generations | GEQO：算法的迭代次数。 | – |
| geqo\$1pool\$1size | GEQO：群体中的个体数。 | – |
| geqo\$1seed | GEQO：随机路径选择的种子。 | – |
| geqo\$1selection\$1bias | GEQO：群体中的选择性压力。 | – |
| geqo\$1threshold | 设置超出其即使用 GEQO 的 FROM 项阈值。 | – |
| gin\$1fuzzy\$1search\$1limit | 通过允许由 GIN 进行的精确搜索得出的最大结果数。 | – |
| gin\$1pending\$1list\$1limit | (kB) 为 GIN 索引设置待处理列表的最大尺寸。 | – |
| hash\$1mem\$1multiplier | 用于哈希表的 work\$1mem 的倍数。 | – |
| hba\$1file | 设置服务器 hba 配置文件。 | /rdsdbdata/config/pg\$1hba.conf |
| hot\$1standby\$1feedback | 允许从热备用项向主备用项提供反馈，避免查询产生冲突。 | on |
| huge\$1pages | 可以减少数据库实例处理大量连续内存数据块（例如共享缓冲区使用的内存数据块）时的开销。对于除 t3.medium、db.t3.large、db.t4g.medium、db.t4g.large 实例类之外的所有数据库实例类，默认情况下都会开启此功能。 | on |
| ident\$1file | 设置服务器身份配置文件。 | /rdsdbdata/config/pg\$1ident.conf |
| idle\$1in\$1transaction\$1session\$1timeout | (ms) 设置允许任何空闲事务的最长持续时间。 | 86400000 |
| idle\$1session\$1timeout | 终止空闲（即等待客户端查询）时间超过指定的时间量但未处于未结事务内的任何会话 | – |
| intervalstyle | 设置间隔值的显示格式。 | – |
| join\$1collapse\$1limit | 设置超出其即不平展 JOIN 结构的 FROM 列表大小。 | – |
| krb\$1caseins\$1users | 设置是否应不区分大小写（true）处理 GSSAPI（通用安全服务 API）用户名。默认情况下，此参数设置为 false，因此 Kerberos 希望用户名区分大小写。有关更多信息，请参阅 PostgreSQL 文档中的 [GSSAPI 身份验证](https://www.postgresql.org/docs/current/gssapi-auth.html)。 | false |
| lc\$1messages | 设置显示消息的语言。 | – |
| lc\$1monetary | 设置用于使货币金额格式化的区域设置。 | – |
| lc\$1numeric | 设置用于使数字格式化的区域设置。 | – |
| lc\$1time | 设置用于使日期和时间值格式化的区域设置。 | – |
| listen\$1addresses | 设置要监听的主机名或 IP 地址。 | \$1 |
| lo\$1compat\$1privileges | 启用大型对象权限检查的向后兼容模式。 | 0 |
| log\$1autovacuum\$1min\$1duration | (ms) 设置如超出即记录 Autovacuum 操作的最短执行时间。 | 10000 |
| log\$1connections | 记录每个成功的连接。 | – |
| log\$1destination | 设置服务器日志输出的目标。 | stderr |
| log\$1directory | 设置日志文件的目标目录。 | /rdsdbdata/log/error |
| log\$1disconnections | 记录会话结束，包括持续时间。 | – |
| log\$1duration | 记录每个完成的 SQL 语句的持续时间。 | – |
| log\$1error\$1verbosity | 设置记录消息的详细程度。 | – |
| log\$1executor\$1stats | 向服务器日志写入执行者性能统计数据。 | – |
| log\$1file\$1mode | 设置日志文件的文件权限。 | 0644 |
| log\$1filename | 设置日志文件的文件名模式。 | postgresql.log.%Y-%m-%d-%H%M |
| logging\$1collector | 启动子进程将 stderr 输出和/或 csvlog 捕获到日志文件中。 | 1 |
| log\$1hostname | 在连接日志中记录主机名。 | 0 |
| logical\$1decoding\$1work\$1mem | (kB) 在溢出到磁盘之前，每个内部重新排序缓冲区都可以使用这么多内存。 | – |
| log\$1line\$1prefix | 控制每个日志行前缀的信息。 | %t:%r:%u@%d:%p]: |
| log\$1lock\$1waits | 记录长锁定等待次数。 | – |
| log\$1min\$1duration\$1sample | (ms) 设置如超出即记录语句示例的最短执行时间。采样率由 log\$1statement\$1sample\$1rate 决定。 | – |
| log\$1min\$1duration\$1statement | (ms) 设置如超出即记录语句的最短执行时间。 | – |
| log\$1min\$1error\$1statement | 导致记录所有产生此级别或更高级别错误的语句。 | – |
| log\$1min\$1messages | 设置记录的消息级别。 | – |
| log\$1parameter\$1max\$1length | (B) 记录语句时，将记录的参数值限制为前 N 个字节。 | – |
| log\$1parameter\$1max\$1length\$1on\$1error | (B) 报告错误时，将记录的参数值限制为前 N 个字节。 | – |
| log\$1parser\$1stats | 向服务器日志写入分析器性能统计数据。 | – |
| log\$1planner\$1stats | 向服务器日志写入计划程序性能统计数据。 | – |
| log\$1replication\$1commands | 记录每个复制命令。 | – |
| log\$1rotation\$1age | (min) 将在 N 分钟后进行日志文件自动轮换。 | 60 |
| log\$1rotation\$1size | (kB) 将在 N kB 后进行日志文件自动轮换。 | 100000 |
| log\$1statement | 设置所记录的语句类型。 | – |
| log\$1statement\$1sample\$1rate | 超过要记录的 log\$1min\$1duration\$1sample 的语句占比。 | – |
| log\$1statement\$1stats | 向服务器日志写入累计性能统计数据。 | – |
| log\$1temp\$1files | (kB) 记录对大于此 kB 数的临时文件的使用情况。 | – |
| log\$1timezone | 设置要在日志消息中使用的时区。 | UTC |
| log\$1transaction\$1sample\$1rate | 设置要为新事务记录的事务的占比。 | – |
| log\$1truncate\$1on\$1rotation | 在日志轮换期间截断同名的现有日志文件。 | 0 |
| maintenance\$1io\$1concurrency | 用于维护工作的 effective\$1io\$1concurrency 变体。 | 1 |
| maintenance\$1work\$1mem | (kB) 设置要用于维护操作的最大内存。 | GREATEST(DBInstanceClassMemory/63963136\$11024,65536) |
| max\$1connections | 设置最大并行连接数。 | LEAST(DBInstanceClassMemory/9531392,5000) |
| max\$1files\$1per\$1process | 设置同时为每个服务器进程打开的最大文件数。 | – |
| max\$1locks\$1per\$1transaction | 设置每个事务的最大锁定数。 | 64 |
| max\$1logical\$1replication\$1workers | 逻辑复制工件进程的最大数量。 | – |
| max\$1parallel\$1maintenance\$1workers | 设置每个维护操作的最大并行进程数。 | – |
| max\$1parallel\$1workers | 设置可同时处于活动状态的最大并行工件数。 | GREATEST(\$1DBInstanceVCPU/2,8) |
| max\$1parallel\$1workers\$1per\$1gather | 设置每个执行程序节点的最大并行进程数。 | – |
| max\$1pred\$1locks\$1per\$1page | 设置每页谓词锁定元组的最大数量。 | – |
| max\$1pred\$1locks\$1per\$1relation | 设置每个关系谓词锁定页和元组的最大数量。 | – |
| max\$1pred\$1locks\$1per\$1transaction | 设置每个事务的最大谓词锁定数。 | – |
| max\$1prepared\$1transactions | 设置同时准备的最大事务数。 | 0 |
| max\$1replication\$1slots | 设置服务器可以支持的最大复制插槽数。 | 20 |
| max\$1slot\$1wal\$1keep\$1size | (MB) 如果 WAL 占用了磁盘这么多空间，复制插槽将标记为失败，并释放分段进行删除或循环使用。 | – |
| max\$1stack\$1depth | 设置最大堆栈长度，以 kB 计。 | 6144 |
| max\$1standby\$1streaming\$1delay | (ms) 设置在有热备用服务器处理流式 WAL 数据时取消查询之前的最大延迟。 | 14000 |
| max\$1sync\$1workers\$1per\$1subscription | 每个订阅的最大同步工件数量 | 2 |
| max\$1wal\$1senders | 设置同时运行的 WAL 发送方的最大数量。 | 10 |
| max\$1worker\$1processes | 设置最大并发工件进程数。 | GREATEST(\$1DBInstanceVCPU\$12,8) |
| min\$1dynamic\$1shared\$1memory | 启动时预留的动态共享内存量（MB）。 | – |
| min\$1parallel\$1index\$1scan\$1size | (8kB) 设置并行扫描的最小索引数据量。 | – |
| min\$1parallel\$1table\$1scan\$1size | (8kB) 设置并行扫描的最小表格数据量。 | – |
| old\$1snapshot\$1threshold | 在快照因时间过长而无法读取在快照捕获后更改的页面的时间（min）。 | – |
| orafce.nls\$1date\$1format | 模拟 Oracle 的日期输出行为。 | – |
| orafce.timezone | 指定用于 sysdate 函数的时区。 | – |
| parallel\$1leader\$1participation | 控制 Gather 和 Gather Merge 是否也运行子计划。 | – |
| parallel\$1setup\$1cost | 设置计划程序预估为并行查询启动工件进程的开销。 | – |
| parallel\$1tuple\$1cost | 设置计划程序预估将每个元组（行）从工件后端传递给主后端的开销。 | – |
| password\$1encryption | 加密密码。 | – |
| pgaudit.log | 指定会话审核日志将记录哪些类语句。 | – |
| pgaudit.log\$1catalog | 指定如果语句中的所有关系都在 pg\$1catalog 中，则启用会话日志记录。 | – |
| pgaudit.log\$1level | 指定将用于日志条目的日志级别。 | – |
| pgaudit.log\$1parameter | 指定审核日志记录应包括随语句传递的参数。 | – |
| pgaudit.log\$1relation | 指定会话审核日志记录是否应为 SELECT 或 DML 语句中引用的每个关系（TABLE、VIEW 等）创建单独的日志条目。 | – |
| pgaudit.log\$1statement\$1once | 指定日志记录在语句/子语句组合中的第一个日志条目中包含语句文本和参数，还是在每个条目中都包含。 | – |
| pgaudit.role | 指定用于对象审核日志记录的主角色。 | – |
| pg\$1bigm.enable\$1recheck | 其将指定是否执行 Recheck，这是全文搜索的内部过程。 | on |
| pg\$1bigm.gin\$1key\$1limit | 其将指定用于全文搜索的搜索关键字的最大 2 元数。 | 0 |
| pg\$1bigm.last\$1update | 其将报告 pg\$1bigm 模块的最后更新日期。 | 2013.11.22 |
| pg\$1bigm.similarity\$1limit | 其将指定相似性搜索使用的最低阈值。 | 0.3 |
| pg\$1hint\$1plan.debug\$1print | 记录提示解析的结果。 | – |
| pg\$1hint\$1plan.enable\$1hint | 强制计划程序使用查询之前的提示注释中指定的计划。 | – |
| pg\$1hint\$1plan.enable\$1hint\$1table | 强制计划程序不通过使用表查找来获得提示。 | – |
| pg\$1hint\$1plan.message\$1level | 调试消息的消息级别。 | – |
| pg\$1hint\$1plan.parse\$1messages | 解析错误的消息级别。 | – |
| pglogical.batch\$1inserts | 在可能时执行批量插入 | – |
| pglogical.conflict\$1log\$1level | 设置用于记录已解决冲突的日志级别。 | – |
| pglogical.conflict\$1resolution | 设置用于解决可解决冲突的方法。 | – |
| pglogical.extra\$1connection\$1options | 要添加到所有对等节点连接的连接选项 | – |
| pglogical.synchronous\$1commit | pglogical 专用的同步提交值 | – |
| pglogical.use\$1spi | 使用 SPI 而非低级 API 来应用更改 | – |
| pgtle.clientauth\$1databases\$1to\$1skip | 要使用 clientauth 功能需要跳过的数据库列表。 | – |
| pgtle.clientauth\$1db\$1name | 控制用于 clientauth 功能的数据库。 | – |
| pgtle.clientauth\$1num\$1parallel\$1workers | 用于 clientauth 功能的后台工作进程数量。 | – |
| pgtle.clientauth\$1users\$1to\$1skip | 要使用 clientauth 功能需要跳过的用户列表。 | – |
| pgtle.enable\$1clientauth | 启用 clientauth 功能。 | – |
| pgtle.passcheck\$1db\$1name | 设置用于集群范围的密码检查功能的数据库。 | – |
| pg\$1prewarm.autoprewarm | 启动自动预热工件。 | – |
| pg\$1prewarm.autoprewarm\$1interval | 设置共享缓冲区转储之间的间隔 | – |
| pg\$1similarity.block\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.block\$1threshold | 设置 Block 相似性函数使用的阈值。 | – |
| pg\$1similarity.block\$1tokenizer | 设置 Block 相似性函数的标记器。 | – |
| pg\$1similarity.cosine\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.cosine\$1threshold | 设置 Cosine 相似性函数使用的阈值。 | – |
| pg\$1similarity.cosine\$1tokenizer | 设置 Cosine 相似性函数的标记器。 | – |
| pg\$1similarity.dice\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.dice\$1threshold | 设置 Dice 相似性测度所使用的阈值。 | – |
| pg\$1similarity.dice\$1tokenizer | 设置 Dice 相似性测度的标记器。 | – |
| pg\$1similarity.euclidean\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.euclidean\$1threshold | 设置 Euclidean 相似性测度所使用的阈值。 | – |
| pg\$1similarity.euclidean\$1tokenizer | 设置 Euclidean 相似性测度的标记器。 | – |
| pg\$1similarity.hamming\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.hamming\$1threshold | 设置 Block 相似性指标使用的阈值。 | – |
| pg\$1similarity.jaccard\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.jaccard\$1threshold | 设置 Jaccard 相似性测度所使用的阈值。 | – |
| pg\$1similarity.jaccard\$1tokenizer | 设置 Jaccard 相似性测度的标记器。 | – |
| pg\$1similarity.jaro\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.jaro\$1threshold | 设置 Jaro 相似性测度所使用的阈值。 | – |
| pg\$1similarity.jarowinkler\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.jarowinkler\$1threshold | 设置 Jarowinkler 相似性测度所使用的阈值。 | – |
| pg\$1similarity.levenshtein\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.levenshtein\$1threshold | 设置 Levenshtein 相似性测度所使用的阈值。 | – |
| pg\$1similarity.matching\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.matching\$1threshold | 设置匹配系数相似性测度所使用的阈值。 | – |
| pg\$1similarity.matching\$1tokenizer | 设置匹配系数相似性测度的标记器。 | – |
| pg\$1similarity.mongeelkan\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.mongeelkan\$1threshold | 设置 Monge-Elkan 相似性测度所使用的阈值。 | – |
| pg\$1similarity.mongeelkan\$1tokenizer | 设置 Monge-Elkan 相似性测度的标记器。 | – |
| pg\$1similarity.nw\$1gap\$1penalty | 设置 Needleman-Wunsch 相似性测度所使用的空位罚分。 | – |
| pg\$1similarity.nw\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.nw\$1threshold | 设置 Needleman-Wunsch 相似性测度所使用的阈值。 | – |
| pg\$1similarity.overlap\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.overlap\$1threshold | 设置重叠系数相似性测度所使用的阈值。 | – |
| pg\$1similarity.overlap\$1tokenizer | 设置重叠系数相似性测度的标记器。 | – |
| pg\$1similarity.qgram\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.qgram\$1threshold | 设置 Q-Gram 相似性测度所使用的阈值。 | – |
| pg\$1similarity.qgram\$1tokenizer | 设置 Q-Gram 测度的标记器。 | – |
| pg\$1similarity.swg\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.swg\$1threshold | 设置 Smith-Waterman-Gotoh 相似性测度所使用的阈值。 | – |
| pg\$1similarity.sw\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.sw\$1threshold | 设置 Smith-Waterman 相似性测度所使用的阈值。 | – |
| pg\$1stat\$1statements.max | 设置 pg\$1stat\$1statements 跟踪的最大语句数。 | – |
| pg\$1stat\$1statements.save | 保存 pg\$1stat\$1statements 在服务器关闭期间的统计数据。 | – |
| pg\$1stat\$1statements.track | 选择 pg\$1stat\$1statements 跟踪哪些语句。 | – |
| pg\$1stat\$1statements.track\$1planning | 选择 pg\$1stat\$1statements 是否跟踪计划持续时间。 | – |
| pg\$1stat\$1statements.track\$1utility | 选择 pg\$1stat\$1statements 是否跟踪实用程序命令。 | – |
| plan\$1cache\$1mode | 控制计划程序对自定义或通用计划的选择。 | – |
| 端口 | 设置服务器侦听的 TCP 端口。 | EndPointPort |
| postgis.gdal\$1enabled\$1drivers | 启用或禁用 Postgres 9.3.5 及更高版本中与 PostGIS 搭配使用的 GDAL 驱动程序。 | ENABLE\$1ALL |
| quote\$1all\$1identifiers | 在生成 SQL 片段时，向所有标识符添加引号。 | – |
| random\$1page\$1cost | 设置计划程序预估非连续提取磁盘页面的开销。 | – |
| rdkit.dice\$1threshold | Dice 相似度阈值较低。通过 \$1 运算，相似性低于阈值的分子不相似。 | – |
| rdkit.do\$1chiral\$1sss | 子结构匹配中是否考虑到立体化学。如果为 false，则子结构匹配中未使用立体化学信息。 | – |
| rdkit.tanimoto\$1threshold | Tanimoto 相似度阈值较低。通过 % 运算，相似性低于阈值的分子不相似。 | – |
| rds.accepted\$1password\$1auth\$1method | 使用本地存储的密码强制对连接进行身份验证。 | md5\$1scram |
| rds.adaptive\$1autovacuum | 用于启用/禁用自适应 Autovacuum 的 RDS 参数。 | 1 |
| rds.babelfish\$1status | 用于启用/禁用 Babelfish for Aurora PostgreSQL 的 RDS 参数。 | off |
| rds.enable\$1plan\$1management | 启用或禁用 apg\$1plan\$1mgmt 扩展。 | 0 |
| rds.extensions | RDS 提供的扩展的列表 | address\$1standardizer、address\$1standardizer\$1data\$1us、apg\$1plan\$1mgmt、aurora\$1stat\$1utils、amcheck、autoinc、aws\$1commons、aws\$1ml、aws\$1s3、aws\$1lambda、bool\$1plperl、bloom、btree\$1gin、btree\$1gist、citext、cube、dblink、dict\$1int、dict\$1xsyn、earthdistance、fuzzystrmatch、hll、hstore、hstore\$1plperl、insert\$1username、intagg、intarray、ip4r、isn、jsonb\$1plperl、lo、log\$1fdw、ltree、moddatetime、old\$1snapshot、oracle\$1fdw、orafce、pgaudit、pgcrypto、pglogical、pgrouting、pgrowlocks、pgstattuple、pgtap、pg\$1bigm、pg\$1buffercache、pg\$1cron、pg\$1freespacemap、pg\$1hint\$1plan、pg\$1partman、pg\$1prewarm、pg\$1proctab、pg\$1repack、pg\$1similarity、pg\$1stat\$1statements、pg\$1trgm、pg\$1visibility、plcoffee、plls、plperl、plpgsql、plprofiler、pltcl、plv8、postgis、postgis\$1tiger\$1geocoder、postgis\$1raster、postgis\$1topology、postgres\$1fdw、prefix、rdkit、rds\$1tools、refint、sslinfo、tablefunc、tds\$1fdw、test\$1parser、tsm\$1system\$1rows、tsm\$1system\$1time、unaccent、uuid-ossp |
| rds.force\$1admin\$1logging\$1level | 请参阅客户数据库中 RDS 管理员用户操作的日志消息。 | – |
| rds.force\$1autovacuum\$1logging\$1level | 请参阅与 Autovacuum 操作相关的日志消息。 | WARNING |
| rds.force\$1ssl | 强制执行 SSL 连接。 | 0 |
| rds.global\$1db\$1rpo | 恢复点目标阈值（以秒为单位），违反该值时会阻止用户提交（s）。 此参数适用于基于 Aurora PostgreSQL 的全球数据库。对于非全球数据库，请将其保留为默认值。有关使用该参数的更多信息，请参阅[管理基于 Aurora PostgreSQL 的全局数据库的 RPO](aurora-global-database-disaster-recovery.md#aurora-global-database-manage-recovery)。 | – |
| rds.logical\$1replication | 启用逻辑解码。 | 0 |
| rds.logically\$1replicate\$1unlogged\$1tables | 逻辑上复制未记录的表。 | 1 |
| rds.log\$1retention\$1period | Amazon RDS 将删除超过 N 分钟的 PostgreSQL 日志。 | 4320 |
| rds.pg\$1stat\$1ramdisk\$1size | 统计数据虚拟磁盘的大小（以 MB 为单位）。将以非零值设置虚拟磁盘。此参数仅在 Aurora PostgreSQL 14 及更低版本中可用。 | 0 |
| rds.rds\$1superuser\$1reserved\$1connections | 设置为 rds\$1superuser 保留的连接插槽数。此参数仅在版本 15 及更高版本中提供。有关更多信息，请参阅 PostgreSQL 文档[预留连接](https://www.postgresql.org/docs/current/runtime-config-connection.html#GUC-RESERVED-CONNECTIONS)。 | 2 |
| rds.restrict\$1password\$1commands | 将与密码相关的命令限制为 rds\$1password 的成员 | – |
| rds.superuser\$1variables | 提升 rds\$1superuser 修改语句的仅限超级用户的变量列表。 | session\$1replication\$1role |
| recovery\$1init\$1sync\$1method | 设置在崩溃恢复之前同步数据目录的方法。 | syncfs |
| remove\$1temp\$1files\$1after\$1crash | 后端崩溃后删除临时文件。 | 0 |
| restart\$1after\$1crash | 后端崩溃后重新初始化服务器。 | – |
| row\$1security | 启用行安全。 | – |
| search\$1path | 设置针对非架构限定名称的架构搜索顺序。 | – |
| seq\$1page\$1cost | 设置计划程序预估连续提取磁盘页面的开销。 | – |
| session\$1replication\$1role | 设置触发器和重写规则的会话行为。 | – |
| shared\$1buffers | (8 kB) 设置服务器使用的共享内存缓冲区数。 | SUM(DBInstanceClassMemory/12038,-50003) |
| shared\$1preload\$1libraries | 列出要预加载到服务器的共享库。 | pg\$1stat\$1statements |
| ssl | 启用 SSL 连接。 | 1 |
| ssl\$1ca\$1file | SSL 服务器授权文件的位置。 | /rdsdbdata/rds-metadata/ca-cert.pem |
| ssl\$1cert\$1file | SSL 服务器证书文件的位置。 | /rdsdbdata/rds-metadata/server-cert.pem |
| ssl\$1ciphers | 设置允许在安全连接上使用的 TLS 密码的列表。 | – |
| ssl\$1crl\$1dir | SSL 证书吊销列表目录的位置。 | /rdsdbdata/rds-metadata/ssl\$1crl\$1dir/ |
| ssl\$1key\$1file | SSL 服务器私有密钥文件的位置 | /rdsdbdata/rds-metadata/server-key.pem |
| ssl\$1max\$1protocol\$1version | 设置允许的最高 SSL/TLS 协议版本 | – |
| ssl\$1min\$1protocol\$1version | 设置允许的最低 SSL/TLS 协议版本 | TLSv1.2 |
| standard\$1conforming\$1strings | 导致 ... 字符串按字面处理反斜杠。 | – |
| statement\$1timeout | (ms) 设置任何语句允许的最长持续时间。 | – |
| stats\$1temp\$1directory | 将临时统计数据文件写入指定目录。 | /rdsdbdata/db/pg\$1stat\$1tmp |
| superuser\$1reserved\$1connections | 设置为超级用户预留的连接插槽数。 | 3 |
| synchronize\$1seqscans | 启用同步顺序扫描。 | – |
| synchronous\$1commit | 设置当前事务同步级别。 | on |
| tcp\$1keepalives\$1count | 重新传输 TCP 保持连接信号的最大次数。 | – |
| tcp\$1keepalives\$1idle | (s) 发出两次 TCP 保持连接信号之间的时间。 | – |
| tcp\$1keepalives\$1interval | (s) 两次 TCP 保持连接信号重新传输之间的时间。 | – |
| temp\$1buffers | (8 kB) 设置每个会话使用的临时缓冲区的最大数量。 | – |
| temp\$1file\$1limit | 限制给定 PostgreSQL 进程可用于临时文件的总磁盘空间（以 kB 为单位），不包括用于显式临时表的空间 | –1 |
| temp\$1tablespaces | 选择用于临时表和排序文件的表空间。 | – |
| timezone | 设置用于显示和解译时间戳的时区。 | UTC |
| track\$1activities | 收集有关执行命令的信息。 | – |
| track\$1activity\$1query\$1size | 设置为 pg\$1stat\$1activity.current\$1query 保留的大小，以字节计。 | 4096 |
| track\$1commit\$1timestamp | 收集事务提交时间。 | – |
| track\$1counts | 收集有关数据库活动的统计数据。 | – |
| track\$1functions | 收集有关数据库活动的函数级别统计数据。 | pl |
| track\$1io\$1timing | 收集有关数据库 IO 活动的时序统计数据。 | 1 |
| track\$1wal\$1io\$1timing | 收集 WAL I/O 活动的时序统计数据。 | – |
| transform\$1null\$1equals | 将 expr=NULL 视为 expr IS NULL。 | – |
| update\$1process\$1title | 更新进程标题以显示活动的 SQL 命令。 | – |
| vacuum\$1cost\$1delay | (ms) Vacuum 开销延迟，以毫秒为单位。 | – |
| vacuum\$1cost\$1limit | 小睡之前可用的真空开销量。 | – |
| vacuum\$1cost\$1page\$1dirty | 由真空弄脏的页面的真空开销。 | – |
| vacuum\$1cost\$1page\$1hit | 在缓冲区缓存中找到的页面的真空开销。 | – |
| vacuum\$1cost\$1page\$1miss | 在缓冲区缓存中未找到的页面的真空开销。 | 0 |
| vacuum\$1defer\$1cleanup\$1age | VACUUM 和 HOT 清理应推迟的事务数（如果有）。 | – |
| vacuum\$1failsafe\$1age | VACUM 应触发故障保护以避免全面停机的期限。 | 1200000000 |
| vacuum\$1freeze\$1min\$1age | VACUUM 应冻结表格行的最短期限。 | – |
| vacuum\$1freeze\$1table\$1age | VACUUM 应扫描整个表以冻结元组的期限。 | – |
| vacuum\$1multixact\$1failsafe\$1age | VACUM 应触发故障保护以避免全面停机的 Multixact 期限。 | 1200000000 |
| vacuum\$1multixact\$1freeze\$1min\$1age | VACUUM 应冻结表格行中的 MultiXactId 的最短期限。 | – |
| vacuum\$1multixact\$1freeze\$1table\$1age | VACUUM 应扫描整个表以冻结元组的 Multixact 期限。 | – |
| wal\$1buffers | 设置 WAL 的共享内存中的磁盘页面缓冲区数（8kB）。 | – |
| wal\$1receiver\$1create\$1temp\$1slot | 设置如果没有配置永久插槽，WAL 接收方是否应创建临时复制插槽。 | 0 |
| wal\$1receiver\$1status\$1interval | (s) 设置 WAL 接收方状态报告到主服务器之间的最大间隔。 | – |
| wal\$1receiver\$1timeout | (ms) 设置从主服务器接收数据的最长等待时间。 | 30000 |
| wal\$1sender\$1timeout | (ms) 设置等待 WAL 复制的最长时间。 | – |
| work\$1mem | (kB) 设置要用于查询工作区的最大内存。 | – |
| xmlbinary | 设置如何将二进制值编码到 XML 中。 | – |
| xmloption | 设置要将隐式分析和序列化操作中的 XML 数据视为文档还是内容片段。 | – |
## Aurora PostgreSQL 实例级参数
您可以使用 AWS 管理控制台、AWS CLI 或 Amazon RDS API 查看特定 Aurora PostgreSQL 版本可用的实例级参数。有关在 RDS 控制台中查看 Aurora PostgreSQL 数据库参数组中的参数的信息，请参阅[在 Amazon Aurora 中查看数据库参数组的参数值](USER_WorkingWithParamGroups.Viewing.md)。
某些实例级参数并非在所有版本中都可用，有些正要弃用。有关查看特定 Aurora PostgreSQL 版本的参数的信息，请参阅[查看 Aurora PostgreSQL 数据库集群和数据库参数](#AuroraPostgreSQL.Reference.ParameterGroups-viewing-parameters)。
例如，下表列出了适用于 Aurora PostgreSQL 数据库集群中特定数据库实例的参数。此列表是通过运行 [describe-db-parameters](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-parameters.html) AWS CLI 命令生成，命令中 `--db-parameter-group-name` 值为 `default.aurora-postgresql14`。
有关此相同默认数据库参数组的数据库集群参数的列表，请参阅 [Aurora PostgreSQL 集群级参数](#AuroraPostgreSQL.Reference.Parameters.Cluster)。
| 参数名称 | 说明 | 默认值 |
| --- | --- | --- |
| apg\$1enable\$1batch\$1mode\$1function\$1execution | 启用批处理模式函数，以便一次处理多行。 | – |
| apg\$1enable\$1correlated\$1any\$1transform | 让计划程序尽可能将关联的 ANY 子链接（IN/NOT IN 子查询）转换为 JOIN。 | – |
| apg\$1enable\$1function\$1migration | 让计划程序将符合条件的标量函数迁移到 FROM 子句。 | – |
| apg\$1enable\$1not\$1in\$1transform | 让计划程序尽可能将 NOT IN 子查询转换为 ANTI JOIN。 | – |
| apg\$1enable\$1remove\$1redundant\$1inner\$1joins | 让计划程序能够删除冗余的内部联接。 | – |
| apg\$1enable\$1semijoin\$1push\$1down | 让哈希联接能够使用半联接筛选条件。 | – |
| apg\$1plan\$1mgmt.capture\$1plan\$1baselines | 捕获计划基准模式。手动：为任何 SQL 语句启用计划捕获；关闭：禁用计划捕获；自动：为 pg\$1stat\$1statements 中满足资格条件的语句启用计划捕获。 | off |
| apg\$1plan\$1mgmt.max\$1databases | 设置可以使用 apg\$1plan\$1mgmt 管理查询的最大数据库数。 | 10 |
| apg\$1plan\$1mgmt.max\$1plans | 设置 apg\$1plan\$1mgmt 可以缓存的最大计划数。 | 10000 |
| apg\$1plan\$1mgmt.plan\$1retention\$1period | 自上次使用计划至自动删除计划之间的最大天数。 | 32 |
| apg\$1plan\$1mgmt.unapproved\$1plan\$1execution\$1threshold | 预估的计划总开销，低于该值则将执行未批准计划。 | 0 |
| apg\$1plan\$1mgmt.use\$1plan\$1baselines | 仅对托管式语句使用已批准计划或固定计划。 | false |
| application\$1name | 设置要在统计数据和日志中报告的应用程序名称。 | – |
| aurora\$1compute\$1plan\$1id | 可以监控查询执行计划，以检测导致当前数据库负载的执行计划，并跟踪一段时间内执行计划的性能统计信息。有关更多信息，请参阅[监控 Aurora PostgreSQL 的查询执行计划](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraPostgreSQL.Monitoring.Query.Plans.html)。 | on |
| aurora\$1temp\$1space\$1size | （MB）在具有支持的实例类的 Aurora I/O 优化型集群上为启用了优化型读取功能的临时对象设置分配空间的大小。 | DBInstanceClassMemory/524288 |
| authentication\$1timeout | 设置允许完成客户端身份验证的最长时间（s）。 | – |
| auto\$1explain.log\$1analyze | 使用 EXPLAIN ANALYZE 记录计划。 | – |
| auto\$1explain.log\$1buffers | 记录缓冲区的使用情况。 | – |
| auto\$1explain.log\$1format | 用于计划记录的 EXPLAIN 格式。 | – |
| auto\$1explain.log\$1min\$1duration | 设置如超出即记录计划的最短执行时间。 | – |
| auto\$1explain.log\$1nested\$1statements | 记录嵌套语句。 | – |
| auto\$1explain.log\$1timing | 不仅收集行数，还收集时序数据。 | – |
| auto\$1explain.log\$1triggers | 在计划中包括触发条件统计数据。 | – |
| auto\$1explain.log\$1verbose | 使用 EXPLAIN VERBOSE 记录计划。 | – |
| auto\$1explain.sample\$1rate | 待处理查询的占比。 | – |
| babelfishpg\$1tds.listen\$1addresses | 设置要侦听 TDS 的主机名或 IP 地址。 | \$1 |
| babelfishpg\$1tds.tds\$1debug\$1log\$1level | 设置 TDS 中的日志记录级别，0 表示禁用日志记录 | 1 |
| backend\$1flush\$1after | 先前执行的写入操作刷写到磁盘的页数（8kB）。 | – |
| bytea\$1output | 设置字节的输出格式。 | – |
| check\$1function\$1bodies | 在 CREATE FUNCTION 期间检查函数体。 | – |
| client\$1connection\$1check\$1interval | 设置在运行查询时检查断开连接的时间间隔。 | – |
| client\$1min\$1messages | 设置发送到客户端的消息级别。 | – |
| config\$1file | 设置服务器主配置文件。 | /rdsdbdata/config/postgresql.conf |
| constraint\$1exclusion | 使计划程序可使用约束优化查询。 | – |
| cpu\$1index\$1tuple\$1cost | 设置计划程序预估索引扫描期间处理每个索引条目的开销。 | – |
| cpu\$1operator\$1cost | 设置计划程序预估处理每个运算符或函数调用的开销。 | – |
| cpu\$1tuple\$1cost | 设置计划程序预估处理每个元组（行）的开销。 | – |
| cron.database\$1name | 设置数据库存储 pg\$1cron 元数据表 | postgres |
| cron.log\$1run | 将所有任务运行记录到 job\$1run\$1details 表中 | on |
| cron.log\$1statement | 在执行之前记录所有 cron 语句。 | off |
| cron.max\$1running\$1jobs | 可以同时运行的最大任务数。 | 5 |
| cron.use\$1background\$1workers | 启用 pg\$1cron 的背景工件 | on |
| cursor\$1tuple\$1fraction | 设置计划程序预估待检索光标行的占比。 | – |
| db\$1user\$1namespace | 启用各数据库的用户名。 | – |
| deadlock\$1timeout | 设置在检查死锁之前等待锁定的时间（ms）。 | – |
| debug\$1pretty\$1print | 缩进分析树和计划树的显示内容。 | – |
| debug\$1print\$1parse | 记录每个查询的分析树。 | – |
| debug\$1print\$1plan | 记录每个查询的执行计划。 | – |
| debug\$1print\$1rewritten | 记录每个查询重写的分析树。 | – |
| default\$1statistics\$1target | 设置默认统计数据目标。 | – |
| default\$1transaction\$1deferrable | 设置新事务的默认可延迟状态。 | – |
| default\$1transaction\$1isolation | 设置每个新事务的事务隔离级别。 | – |
| default\$1transaction\$1read\$1only | 设置新事务的默认只读状态。 | – |
| effective\$1cache\$1size | 设置计划程序对于磁盘缓存大小的假设（8kB）。 | SUM(DBInstanceClassMemory/12038,-50003 |
| effective\$1io\$1concurrency | 磁盘子系统可有效处理的并行请求数。 | – |
| enable\$1async\$1append | 使计划程序可使用异步追加计划。 | – |
| enable\$1bitmapscan | 使计划程序可使用位图扫描计划。 | – |
| enable\$1gathermerge | 使计划程序可使用收集合并计划。 | – |
| enable\$1hashagg | 使计划程序可使用哈希聚合计划。 | – |
| enable\$1hashjoin | 使计划程序可使用哈希联接计划。 | – |
| enable\$1incremental\$1sort | 使计划程序可使用增量排序步骤。 | – |
| enable\$1indexonlyscan | 使计划程序可使用仅限索引的扫描计划。 | – |
| enable\$1indexscan | 使计划程序可使用索引扫描计划。 | – |
| enable\$1material | 使计划程序可使用具体化。 | – |
| enable\$1memoize | 使计划程序可使用记忆功能 | – |
| enable\$1mergejoin | 使计划程序可使用合并联接计划。 | – |
| enable\$1nestloop | 使计划程序可使用嵌套循环的联接计划。 | – |
| enable\$1parallel\$1append | 使计划程序可使用并行追加计划。 | – |
| enable\$1parallel\$1hash | 使计划程序可使用并行哈希计划。 | – |
| enable\$1partition\$1pruning | 启用计划时和运行时分区修剪。 | – |
| enable\$1partitionwise\$1aggregate | 启用智能分区聚合和分组。 | – |
| enable\$1partitionwise\$1join | 启用智能分区联接。 | – |
| enable\$1seqscan | 使计划程序可使用顺序扫描计划。 | – |
| enable\$1sort | 使计划程序可使用显式排序步骤。 | – |
| enable\$1tidscan | 使计划程序可使用 TID 扫描计划。 | – |
| escape\$1string\$1warning | 警告在普通字符串文本中有反斜杠转义符。 | – |
| exit\$1on\$1error | 发生任何错误时终止会话。 | – |
| force\$1parallel\$1mode | 强制使用并行查询功能。 | – |
| from\$1collapse\$1limit | 设置超出其即不折叠子查询的 FROM 列表大小。 | – |
| geqo | 启用基因查询优化。 | – |
| geqo\$1effort | GEQO：用于设置其他 GEQO 参数默认值的工作负载。 | – |
| geqo\$1generations | GEQO：算法的迭代次数。 | – |
| geqo\$1pool\$1size | GEQO：群体中的个体数。 | – |
| geqo\$1seed | GEQO：随机路径选择的种子。 | – |
| geqo\$1selection\$1bias | GEQO：群体中的选择性压力。 | – |
| geqo\$1threshold | 设置超出其即使用 GEQO 的 FROM 项阈值。 | – |
| gin\$1fuzzy\$1search\$1limit | 通过允许由 GIN 进行的精确搜索得出的最大结果数。 | – |
| gin\$1pending\$1list\$1limit | 为 GIN 索引设置待处理列表的最大大小（kB）。 | – |
| hash\$1mem\$1multiplier | 用于哈希表的 work\$1mem 的倍数。 | – |
| hba\$1file | 设置服务器 hba 配置文件。 | /rdsdbdata/config/pg\$1hba.conf |
| hot\$1standby\$1feedback | 允许从热备用项向主备用项提供反馈，避免查询产生冲突。 | on |
| ident\$1file | 设置服务器身份配置文件。 | /rdsdbdata/config/pg\$1ident.conf |
| idle\$1in\$1transaction\$1session\$1timeout | 设置允许任何空闲事务的最长持续时间（ms）。 | 86400000 |
| idle\$1session\$1timeout | 终止空闲（即等待客户端查询）时间超过指定的时间量但未处于未结事务内的任何会话 | – |
| join\$1collapse\$1limit | 设置超出其即不平展 JOIN 结构的 FROM 列表大小。 | – |
| lc\$1messages | 设置显示消息的语言。 | – |
| listen\$1addresses | 设置要侦听的主机名或 IP 地址。 | \$1 |
| lo\$1compat\$1privileges | 启用大型对象权限检查的向后兼容模式。 | 0 |
| log\$1connections | 记录每个成功的连接。 | – |
| log\$1destination | 设置服务器日志输出的目标。 | stderr |
| log\$1directory | 设置日志文件的目标目录。 | /rdsdbdata/log/error |
| log\$1disconnections | 记录会话结束，包括持续时间。 | – |
| log\$1duration | 记录每个完成的 SQL 语句的持续时间。 | – |
| log\$1error\$1verbosity | 设置记录消息的详细程度。 | – |
| log\$1executor\$1stats | 向服务器日志写入执行者性能统计数据。 | – |
| log\$1file\$1mode | 设置日志文件的文件权限。 | 0644 |
| log\$1filename | 设置日志文件的文件名模式。 | postgresql.log.%Y-%m-%d-%H%M |
| logging\$1collector | 启动子进程将 stderr 输出和/或 csvlog 捕获到日志文件中。 | 1 |
| log\$1hostname | 在连接日志中记录主机名。 | 0 |
| logical\$1decoding\$1work\$1mem | 在溢出到磁盘之前，每个内部重新排序缓冲区都可以使用这么多内存（kB）。 | – |
| log\$1line\$1prefix | 控制每个日志行前缀的信息。 | %t:%r:%u@%d:%p]: |
| log\$1lock\$1waits | 记录长锁定等待次数。 | – |
| log\$1min\$1duration\$1sample | 设置如超出即记录语句示例的最短执行时间（ms）。采样率由 log\$1statement\$1sample\$1rate 决定。 | – |
| log\$1min\$1duration\$1statement | 设置如超出即记录语句的最短执行时间（ms）。 | – |
| log\$1min\$1error\$1statement | 导致记录所有产生此级别或更高级别错误的语句。 | – |
| log\$1min\$1messages | 设置记录的消息级别。 | – |
| log\$1parameter\$1max\$1length | 记录语句时，将记录的参数值限制为前 N 个字节（B）。 | – |
| log\$1parameter\$1max\$1length\$1on\$1error | 报告错误时，将记录的参数值限制为前 N 个字节（B）。 | – |
| log\$1parser\$1stats | 向服务器日志写入分析器性能统计数据。 | – |
| log\$1planner\$1stats | 向服务器日志写入计划程序性能统计数据。 | – |
| log\$1replication\$1commands | 记录每个复制命令。 | – |
| log\$1rotation\$1age | N 分钟后将发生日志文件自动轮换（min）。 | 60 |
| log\$1rotation\$1size | 在 N kB 后将发生日志文件自动轮换（kB）。 | 100000 |
| log\$1statement | 设置所记录的语句类型。 | – |
| log\$1statement\$1sample\$1rate | 超过要记录的 log\$1min\$1duration\$1sample 的语句占比。 | – |
| log\$1statement\$1stats | 向服务器日志写入累计性能统计数据。 | – |
| log\$1temp\$1files | 记录大于此 kB 数的临时文件的使用情况（kB）。 | – |
| log\$1timezone | 设置要在日志消息中使用的时区。 | UTC |
| log\$1truncate\$1on\$1rotation | 在日志轮换期间截断同名的现有日志文件。 | 0 |
| maintenance\$1io\$1concurrency | 用于维护工作的 effective\$1io\$1concurrency 变体。 | 1 |
| maintenance\$1work\$1mem | 设置要用于维护操作的最大内存（kB）。 | GREATEST(DBInstanceClassMemory/63963136\$11024,65536 |
| max\$1connections | 设置最大并行连接数。 | LEAST(DBInstanceClassMemory/9531392,5000 |
| max\$1files\$1per\$1process | 设置同时为每个服务器进程打开的最大文件数。 | – |
| max\$1locks\$1per\$1transaction | 设置每个事务的最大锁定数。 | 64 |
| max\$1parallel\$1maintenance\$1workers | 设置每个维护操作的最大并行进程数。 | – |
| max\$1parallel\$1workers | 设置可同时处于活动状态的最大并行工件数。 | GREATEST(\$1DBInstanceVCPU/2,8 |
| max\$1parallel\$1workers\$1per\$1gather | 设置每个执行程序节点的最大并行进程数。 | – |
| max\$1pred\$1locks\$1per\$1page | 设置每页谓词锁定元组的最大数量。 | – |
| max\$1pred\$1locks\$1per\$1relation | 设置每个关系谓词锁定页和元组的最大数量。 | – |
| max\$1pred\$1locks\$1per\$1transaction | 设置每个事务的最大谓词锁定数。 | – |
| max\$1slot\$1wal\$1keep\$1size | 如果 WAL 占用了磁盘这么多空间，复制插槽将标记为失败，并释放分段进行删除或循环使用（MB）。 | – |
| max\$1stack\$1depth | 设置最大堆栈长度，以 kB 计（kB）。 | 6144 |
| max\$1standby\$1streaming\$1delay | 设置在有热备用服务器处理流式传输 WAL 数据时取消查询之前的最大延迟（ms）。 | 14000 |
| max\$1worker\$1processes | 设置最大并发工件进程数。 | GREATEST(\$1DBInstanceVCPU\$12,8 |
| min\$1dynamic\$1shared\$1memory | 启动时预留的动态共享内存量（MB）。 | – |
| min\$1parallel\$1index\$1scan\$1size | 设置并行扫描的最小索引数据量（8kB）。 | – |
| min\$1parallel\$1table\$1scan\$1size | 设置并行扫描的最小表格数据量（8kB）。 | – |
| old\$1snapshot\$1threshold | 在快照因时间过长而无法读取捕获快照后更改的页面的时间（min）。 | – |
| parallel\$1leader\$1participation | 控制 Gather 和 Gather Merge 是否也运行子计划。 | – |
| parallel\$1setup\$1cost | 设置计划程序预估为并行查询启动工件进程的开销。 | – |
| parallel\$1tuple\$1cost | 设置计划程序预估将每个元组（行）从工件后端传递给主后端的开销。 | – |
| pgaudit.log | 指定会话审核日志将记录哪些类语句。 | – |
| pgaudit.log\$1catalog | 指定如果语句中的所有关系都在 pg\$1catalog 中，则启用会话日志记录。 | – |
| pgaudit.log\$1level | 指定将用于日志条目的日志级别。 | – |
| pgaudit.log\$1parameter | 指定审核日志记录应包括随语句传递的参数。 | – |
| pgaudit.log\$1relation | 指定会话审核日志记录是否应为 SELECT 或 DML 语句中引用的每个关系（TABLE、VIEW 等）创建单独的日志条目。 | – |
| pgaudit.log\$1statement\$1once | 指定日志记录在语句/子语句组合中的第一个日志条目中包含语句文本和参数，还是在每个条目中都包含。 | – |
| pgaudit.role | 指定用于对象审核日志记录的主角色。 | – |
| pg\$1bigm.enable\$1recheck | 其将指定是否执行 Recheck，这是全文搜索的内部过程。 | on |
| pg\$1bigm.gin\$1key\$1limit | 其将指定用于全文搜索的搜索关键字的最大 2 元数。 | 0 |
| pg\$1bigm.last\$1update | 其将报告 pg\$1bigm 模块的最后更新日期。 | 2013.11.22 |
| pg\$1bigm.similarity\$1limit | 其将指定相似性搜索使用的最低阈值。 | 0.3 |
| pg\$1hint\$1plan.debug\$1print | 记录提示解析的结果。 | – |
| pg\$1hint\$1plan.enable\$1hint | 强制计划程序使用查询之前的提示注释中指定的计划。 | – |
| pg\$1hint\$1plan.enable\$1hint\$1table | 强制计划程序不通过使用表查找来获得提示。 | – |
| pg\$1hint\$1plan.message\$1level | 调试消息的消息级别。 | – |
| pg\$1hint\$1plan.parse\$1messages | 解析错误的消息级别。 | – |
| pglogical.batch\$1inserts | 在可能时执行批量插入 | – |
| pglogical.conflict\$1log\$1level | 设置用于记录已解决冲突的日志级别。 | – |
| pglogical.conflict\$1resolution | 设置用于解决可解决冲突的方法。 | – |
| pglogical.extra\$1connection\$1options | 要添加到所有对等节点连接的连接选项 | – |
| pglogical.synchronous\$1commit | pglogical 专用的同步提交值 | – |
| pglogical.use\$1spi | 使用 SPI 而非低级 API 来应用更改 | – |
| pg\$1similarity.block\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.block\$1threshold | 设置 Block 相似性函数使用的阈值。 | – |
| pg\$1similarity.block\$1tokenizer | 设置 Block 相似性函数的标记器。 | – |
| pg\$1similarity.cosine\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.cosine\$1threshold | 设置 Cosine 相似性函数使用的阈值。 | – |
| pg\$1similarity.cosine\$1tokenizer | 设置 Cosine 相似性函数的标记器。 | – |
| pg\$1similarity.dice\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.dice\$1threshold | 设置 Dice 相似性测度所使用的阈值。 | – |
| pg\$1similarity.dice\$1tokenizer | 设置 Dice 相似性测度的标记器。 | – |
| pg\$1similarity.euclidean\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.euclidean\$1threshold | 设置 Euclidean 相似性测度所使用的阈值。 | – |
| pg\$1similarity.euclidean\$1tokenizer | 设置 Euclidean 相似性测度的标记器。 | – |
| pg\$1similarity.hamming\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.hamming\$1threshold | 设置 Block 相似性指标使用的阈值。 | – |
| pg\$1similarity.jaccard\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.jaccard\$1threshold | 设置 Jaccard 相似性测度所使用的阈值。 | – |
| pg\$1similarity.jaccard\$1tokenizer | 设置 Jaccard 相似性测度的标记器。 | – |
| pg\$1similarity.jaro\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.jaro\$1threshold | 设置 Jaro 相似性测度所使用的阈值。 | – |
| pg\$1similarity.jarowinkler\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.jarowinkler\$1threshold | 设置 Jarowinkler 相似性测度所使用的阈值。 | – |
| pg\$1similarity.levenshtein\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.levenshtein\$1threshold | 设置 Levenshtein 相似性测度所使用的阈值。 | – |
| pg\$1similarity.matching\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.matching\$1threshold | 设置匹配系数相似性测度所使用的阈值。 | – |
| pg\$1similarity.matching\$1tokenizer | 设置匹配系数相似性测度的标记器。 | – |
| pg\$1similarity.mongeelkan\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.mongeelkan\$1threshold | 设置 Monge-Elkan 相似性测度所使用的阈值。 | – |
| pg\$1similarity.mongeelkan\$1tokenizer | 设置 Monge-Elkan 相似性测度的标记器。 | – |
| pg\$1similarity.nw\$1gap\$1penalty | 设置 Needleman-Wunsch 相似性测度所使用的空位罚分。 | – |
| pg\$1similarity.nw\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.nw\$1threshold | 设置 Needleman-Wunsch 相似性测度所使用的阈值。 | – |
| pg\$1similarity.overlap\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.overlap\$1threshold | 设置重叠系数相似性测度所使用的阈值。 | – |
| pg\$1similarity.overlap\$1tokenizer | 设置重叠系数相似性测度的标记器。 | – |
| pg\$1similarity.qgram\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.qgram\$1threshold | 设置 Q-Gram 相似性测度所使用的阈值。 | – |
| pg\$1similarity.qgram\$1tokenizer | 设置 Q-Gram 测度的标记器。 | – |
| pg\$1similarity.swg\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.swg\$1threshold | 设置 Smith-Waterman-Gotoh 相似性测度所使用的阈值。 | – |
| pg\$1similarity.sw\$1is\$1normalized | 设置结果值是否标准化。 | – |
| pg\$1similarity.sw\$1threshold | 设置 Smith-Waterman 相似性测度所使用的阈值。 | – |
| pg\$1stat\$1statements.max | 设置 pg\$1stat\$1statements 跟踪的最大语句数。 | – |
| pg\$1stat\$1statements.save | 保存 pg\$1stat\$1statements 在服务器关闭期间的统计数据。 | – |
| pg\$1stat\$1statements.track | 选择 pg\$1stat\$1statements 跟踪哪些语句。 | – |
| pg\$1stat\$1statements.track\$1planning | 选择 pg\$1stat\$1statements 是否跟踪计划持续时间。 | – |
| pg\$1stat\$1statements.track\$1utility | 选择 pg\$1stat\$1statements 是否跟踪实用程序命令。 | – |
| postgis.gdal\$1enabled\$1drivers | 启用或禁用 Postgres 9.3.5 及更高版本中与 PostGIS 搭配使用的 GDAL 驱动程序。 | ENABLE\$1ALL |
| quote\$1all\$1identifiers | 在生成 SQL 片段时，向所有标识符添加引号。 | – |
| random\$1page\$1cost | 设置计划程序预估非连续提取磁盘页面的开销。 | – |
| rds.enable\$1memory\$1management | 改进了 Aurora PostgreSQL 12.17、13.13、14.10、15.5 及更高版本中的内存管理功能，可防止因可用内存不足而导致的稳定性问题和数据库重启。有关更多信息，请参阅 [改进了 Aurora PostgreSQL 中的内存管理限制](AuroraPostgreSQL.BestPractices.memory.management.md)。 | True |
| rds.force\$1admin\$1logging\$1level | 请参阅客户数据库中 RDS 管理员用户操作的日志消息。 | – |
| rds.log\$1retention\$1period | Amazon RDS 将删除超过 N 分钟的 PostgreSQL 日志。 | 4320 |
| rds.memory\$1allocation\$1guard | 改进了 Aurora PostgreSQL 11.21、12.16、13.12、14.9、15.4 及更早版本中的内存管理功能，可防止因可用内存不足而导致的稳定性问题和数据库重启。有关更多信息，请参阅 [改进了 Aurora PostgreSQL 中的内存管理限制](AuroraPostgreSQL.BestPractices.memory.management.md)。 | False |
| rds.pg\$1stat\$1ramdisk\$1size | 统计数据虚拟磁盘的大小（以 MB 为单位）。将以非零值设置虚拟磁盘。 | 0 |
| rds.rds\$1superuser\$1reserved\$1connections | 设置为 rds\$1superuser 保留的连接插槽数。此参数仅在版本 15 及更高版本中提供。有关更多信息，请参阅 PostgreSQL 文档[预留连接](https://www.postgresql.org/docs/current/runtime-config-connection.html#GUC-RESERVED-CONNECTIONS)。 | 2 |
| rds.superuser\$1variables | 提升 rds\$1superuser 修改语句的仅限超级用户的变量列表。 | session\$1replication\$1role |
| remove\$1temp\$1files\$1after\$1crash | 后端崩溃后删除临时文件。 | 0 |
| restart\$1after\$1crash | 后端崩溃后重新初始化服务器。 | – |
| row\$1security | 启用行安全。 | – |
| search\$1path | 设置针对非架构限定名称的架构搜索顺序。 | – |
| seq\$1page\$1cost | 设置计划程序预估连续提取磁盘页面的开销。 | – |
| session\$1replication\$1role | 设置触发器和重写规则的会话行为。 | – |
| shared\$1buffers | (8 kB) 设置服务器使用的共享内存缓冲区数。 | SUM(DBInstanceClassMemory/12038,-50003) |
| shared\$1preload\$1libraries | 列出要预加载到服务器的共享库。 | pg\$1stat\$1statements |
| ssl\$1ca\$1file | SSL 服务器授权文件的位置。 | /rdsdbdata/rds-metadata/ca-cert.pem |
| ssl\$1cert\$1file | SSL 服务器证书文件的位置。 | /rdsdbdata/rds-metadata/server-cert.pem |
| ssl\$1crl\$1dir | SSL 证书吊销列表目录的位置。 | /rdsdbdata/rds-metadata/ssl\$1crl\$1dir/ |
| ssl\$1key\$1file | SSL 服务器私有密钥文件的位置 | /rdsdbdata/rds-metadata/server-key.pem |
| standard\$1conforming\$1strings | 导致 ... 字符串按字面处理反斜杠。 | – |
| statement\$1timeout | 设置任何语句允许的最长持续时间（ms）。 | – |
| stats\$1temp\$1directory | 将临时统计数据文件写入指定目录。 | /rdsdbdata/db/pg\$1stat\$1tmp |
| superuser\$1reserved\$1connections | 设置为超级用户预留的连接插槽数。 | 3 |
| synchronize\$1seqscans | 启用同步顺序扫描。 | – |
| tcp\$1keepalives\$1count | 重新传输 TCP 保持连接信号的最大次数。 | – |
| tcp\$1keepalives\$1idle | 发出两次 TCP 保持连接信号之间的时间（s）。 | – |
| tcp\$1keepalives\$1interval | 两次 TCP 保持连接信号重新传输之间的时间（s）。 | – |
| temp\$1buffers | 设置每个会话使用的临时缓冲区的最大数量（8kB）。 | – |
| temp\$1file\$1limit | 限制给定 PostgreSQL 进程可用于临时文件的总磁盘空间（以 kB 为单位），不包括用于显式临时表的空间 | –1 |
| temp\$1tablespaces | 选择用于临时表和排序文件的表空间。 | – |
| track\$1activities | 收集有关执行命令的信息。 | – |
| track\$1activity\$1query\$1size | 设置为 pg\$1stat\$1activity.current\$1query 保留的大小，以字节计。 | 4096 |
| track\$1counts | 收集有关数据库活动的统计数据。 | – |
| track\$1functions | 收集有关数据库活动的函数级别统计数据。 | pl |
| track\$1io\$1timing | 收集有关数据库 IO 活动的时序统计数据。 | 1 |
| transform\$1–\$1equals | 将 expr=– 视为 expr IS –。 | – |
| update\$1process\$1title | 更新进程标题以显示活动的 SQL 命令。 | – |
| wal\$1receiver\$1status\$1interval | 设置向主服务器报告 WAL 接收方状态之间的最大间隔（s）。 | – |
| work\$1mem | 设置要用于查询工作区的最大内存（kB）。 | – |
| xmlbinary | 设置如何将二进制值编码到 XML 中。 | – |
| xmloption | 设置要将隐式分析和序列化操作中的 XML 数据视为文档还是内容片段。 | – |
# Amazon Aurora PostgreSQL 等待事件
以下是 Aurora PostgreSQL 的常见等待事件。要了解有关等待事件和调整 Aurora PostgreSQL 数据库集群的更多信息，请参阅[使用 Aurora PostgreSQL 的等待事件进行优化](AuroraPostgreSQL.Tuning.md)。
**Activity:ArchiverMain**
存档程序正在等待活动。
**Activity:AutoVacuumMain**
Autovacuum 启动程序进程正在等待活动。
**Activity:BgWriterHibernate**
后台写入进程在等待活动时进入休眠状态。
**Activity:BgWriterMain**
后台写入器进程正在等待活动。
**Activity:CheckpointerMain**
检查指针进程正在等待活动。
**Activity:LogicalApplyMain**
逻辑复制应用进程正在等待活动。
**Activity:LogicalLauncherMain**
逻辑复制启动器进程正在等待活动。
**Activity:PgStatMain**
统计数据收集器进程正在等待活动。
**Activity:RecoveryWalAll**
进程正在等待恢复时来自流的预写日志 (WAL)。
**Activity:RecoveryWalStream**
启动进程正在等待流式恢复期间到达的预写日志 (WAL)。
**Activity:SysLoggerMain**
syslogger 过程正在等待活动。
**Activity:WalReceiverMain**
预写日志 (WAL) 接收方进程正在等待活动。
**Activity:WalSenderMain**
预写日志 (WAL) 发件人进程正在等待活动。
**Activity:WalWriterMain**
预写日志 (WAL) 写入器进程正在等待活动。
**BufferPin:BufferPin**
进程正在等待在缓冲区上获取专属 PIN。
**Client:GSSOpenServer**
进程正在等待从客户端读取数据，同时建立通用安全服务应用程序接口 (GSSAPI) 会话。
**Client:ClientRead**
后端进程正在等待从 PostgreSQL 客户端接收数据。有关更多信息，请参阅 [Client:ClientRead](apg-waits.clientread.md)。
**Client:ClientWrite**
后端进程正在等待将更多数据发送到 PostgreSQL 客户端。有关更多信息，请参阅 [Client:ClientWrite](apg-waits.clientwrite.md)。
**Client:LibPQWalReceiverConnect**
进程正在等待预写日志 (WAL) 接收方与远程服务器建立连接。
**Client:LibPQWalReceiverReceive**
进程在预写日志 (WAL) 接收方等待从远程服务器接收数据。
**Client:SSLOpenServer**
进程正在等待尝试连接时的安全套接字层 (SSL)。
**Client:WalReceiverWaitStart**
进程正在等待启动过程发送初始数据以进行流式复制。
**Client:WalSenderWaitForWAL**
进程正等待在 WAL 发件人进程中刷新预写日志 (WAL)。
**Client:WalSenderWriteData**
进程正在等待 WAL 发件人进程中处理来自预写日志 (WAL) 接收方的回复时的任何活动。
**CPU**
后端进程处于活动状态或正在等待 CPU。有关更多信息，请参阅 [CPU](apg-waits.cpu.md)。
**Extension:extension**
后端进程正在等待扩展或模块定义的条件。
**IO:AuroraEnhancedLogicalWALRead**
一个后端进程正在从更改数据捕获（CDC）卷获取日志记录。
**IO:AuroraOptimizedReadsCacheRead**
进程正在等待从优化型读取分层缓存中读取数据，因为页面在共享内存中不可用。
**IO:AuroraOptimizedReadsCacheSegmentTruncate**
进程正在等待优化型分层缓存段文件被截断。
**IO:AuroraOptimizedReadsCacheWrite**
后台写入器进程正在等待在优化型读取分层缓存中进行写入。
**IO:AuroraStorageLogAllocate**
会话正在分配元数据并准备写入事务日志。
**IO:BufFileRead**
当操作需要的内存超过工作内存参数定义的数量时，引擎将在磁盘上创建临时文件。当操作从临时文件中读取时，会发生此等待事件。有关更多信息，请参阅 [IO:BufFileRead 和 IO:BufFileWrite](apg-waits.iobuffile.md)。
**IO:BufFileWrite**
当操作需要的内存超过工作内存参数定义的数量时，引擎将在磁盘上创建临时文件。当操作写入临时文件时，会发生此等待事件。有关更多信息，请参阅 [IO:BufFileRead 和 IO:BufFileWrite](apg-waits.iobuffile.md)。
**IO:ControlFileRead**
进程正在等待从 `pg_control` 文件中进行读取。
**IO:ControlFileSync**
进程正在等待 `pg_control` 文件到达持久存储空间。
**IO:ControlFileSyncUpdate**
进程正在等待 `pg_control` 文件更新以到达持久存储空间。
**IO:ControlFileWrite**
进程正在等待写入 `pg_control` 文件。
**IO:ControlFileWriteUpdate**
进程正在等待写入以更新 `pg_control` 文件。
**IO:CopyFileRead**
进程正在等待文件复制操作期间进行读取。
**IO:CopyFileWrite**
在文件复制操作期间，进程正在等待写入。
**IO:DataFileExtend**
进程正在等待扩展关系数据文件。
**IO:DataFileFlush**
进程正在等待关系数据文件到达持久存储空间。
**IO:DataFileImmediateSync**
进程正在等待关系数据文件被立即同步到持久存储空间。
**IO:DataFilePrefetch**
进程正在等待从关系数据文件中进行异步预提取。
**IO:DataFileSync**
进程正在等待关系数据文件的更改到达持久存储空间。
**IO:DataFileRead**
后端进程试图在共享缓冲区中找到一个页面，但没有找到该页面，因此从存储中读取它。有关更多信息，请参阅 [IO:DataFileRead](apg-waits.iodatafileread.md)。
**IO:DataFileTruncate**
进程正在等待关系数据文件被截断。
**IO:DataFileWrite**
进程正在等待写入关系数据文件。
**IO:DSMFillZeroWrite**
进程正在等待向动态共享内存备份文件写入零字节。
**IO:LockFileAddToDataDirRead**
进程正在等待向数据目录锁定文件添加行时进行读取。
**IO:LockFileAddToDataDirSync**
在向数据目录锁定文件添加行时，进程正在等待数据到达持久存储空间。
**IO:LockFileAddToDataDirWrite**
在向数据目录锁定文件添加行时，进程正在等待写入。
**IO:LockFileCreateRead**
在创建数据目录锁定文件时，进程正在等待读取。
**IO:LockFileCreateSync**
在创建数据目录锁定文件时，进程正在等待数据到达持久存储空间。
**IO:LockFileCreateWrite**
在创建数据目录锁定文件时，进程正在等待写入。
**IO:LockFileReCheckDataDirRead**
进程正在等待重新检查数据目录锁定文件期间进行读取。
**IO:LogicalRewriteCheckpointSync**
进程正在等待逻辑重写映射在检查点期间到达持久存储空间。
**IO:LogicalRewriteMappingSync**
进程正在等待映射数据在逻辑重写期间到达持久存储空间。
**IO:LogicalRewriteMappingWrite**
进程正在等待逻辑重写期间写入映射数据。
**IO:LogicalRewriteSync**
进程正在等待逻辑重写映射到达持久存储空间。
**IO:LogicalRewriteTruncate**
在逻辑重写期间，进程正在等待映射数据的截断。
**IO:LogicalRewriteWrite**
进程正在等待逻辑重写映射的写入。
**IO:RelationMapRead**
进程正在等待关系映射文件的读取。
**IO:RelationMapSync**
进程正在等待关系映射文件到达持久存储空间。
**IO:RelationMapWrite**
进程正在等待写入关系映射文件。
**IO:ReorderBufferRead**
进程正在重新排序缓冲区管理期间等待读取。
**IO:ReorderBufferWrite**
进程正在重新排序缓冲区管理期间等待写入。
**IO:ReorderLogicalMappingRead**
进程正在重新排序缓冲区管理期间等待逻辑映射读取。
**IO:ReplicationSlotRead**
进程正在等待从复制插槽控制文件中读取。
**IO:ReplicationSlotRestoreSync**
进程正在等待复制插槽控制文件在将其恢复到内存时到达持久存储空间。
**IO:ReplicationSlotSync**
进程正在等待复制插槽控制文件到达持久存储空间。
**IO:ReplicationSlotWrite**
进程正在等待写入复制插槽控制文件中。
**IO:SLRUFlushSync**
进程正在等待检查点或数据库关闭期间最近使用最少的（SLRU）的简单数据到达持久存储空间。
**IO:SLRURead**
进程正在等待读取最近使用最少（SLRU）的简单页面。
**IO:SLRUSync**
进程正在等待写入页面后最近最少使用（SLRU）的简单数据到达持久存储空间。
**IO:SLRUWrite**
进程正在等待写入最近使用最少（SLRU）的简单页面。
**IO:SnapbuildRead**
进程正在等待读取序列化的历史目录快照。
**IO:SnapbuildSync**
进程正在等待序列化的历史目录快照到达持久存储空间。
**IO:SnapbuildWrite**
进程正在等待写入序列化的历史目录快照。
**IO:TimelineHistoryFileSync**
进程正在等待通过流式复制接收的时间线历史记录文件到达持久存储空间。
**IO:TimelineHistoryFileWrite**
进程正在等待写入通过流式复制接收的时间表历史记录文件。
**IO:TimelineHistoryRead**
进程正在等待读取时间线历史记录文件。
**IO:TimelineHistorySync**
进程正在等待新创建的时间线历史记录文件到达持久存储空间。
**IO:TimelineHistoryWrite**
进程正在等待写入新创建的时间线历史记录文件。
**IO:TwophaseFileRead**
进程正在等待读取两阶段状态文件。
**IO:TwophaseFileSync**
进程正在等待两阶段状态文件到达持久存储空间。
**IO:TwophaseFileWrite**
进程正在等待写入两阶段状态文件。
**IO:WALBootstrapSync**
进程正在等待引导启动过程中到达持久存储空间的预写日志 (WAL)。
**IO:WALBootstrapWrite**
进程正在等待引导启动过程中写入预写日志 (WAL) 页面。
**IO:WALCopyRead**
进程正在等待通过复制现有预写日志段创建新的预写日志 (WAL) 段时进行读取。
**IO:WALCopySync**
进程正等待通过复制现有预写日志段创建的新预写日志 (WAL) 段到达持久存储空间。
**IO:WALCopyWrite**
通过复制现有预写日志段创建新的预写日志 (WAL) 段时，进程正在等待写入。
**IO:WALInitSync**
进程正在等待新初始化的预写日志 (WAL) 文件到达持久存储空间。
**IO:WALInitWrite**
进程正在等待新初始化预写日志 (WAL) 文件时进行写入。
**IO:WALRead**
进程正在等待读取预写日志 (WAL) 文件。
**IO:WALSenderTimelineHistoryRead**
进程正在等待从 WAL 发件人时间线命令期间的时间线历史记录文件进行读取。
**IO:WALSync**
进程正在等待预写日志 (WAL) 文件到达持久存储空间。
**IO:WALSyncMethodAssign**
进程在分配新的预写日志 (WAL) 同步方法时等待数据到达持久存储空间。
**IO:WALWrite**
进程正等待写入预写日志 (WAL) 文件。
**IO:XactSync**
后端进程正在等待 Aurora 存储子系统确认常规事务的提交，或者准备好的事务的提交或回滚。有关更多信息，请参阅 [IO:XactSync](apg-waits.xactsync.md)。
**IPC:AuroraLogicalSchemaUpdate**
两个后端进程正在尝试将同一条目插入架构缓存。一个进程将继续，而另一个进程则等待其完成。
**IPC:AuroraOptimizedReadsCacheWriteStop**
进程正在等待后台写入器停止写入优化型读取分层缓存。
**IPC:BackupWaitWalArchive**
进程正在等待成功存档备份所需的预写日志 (WAL) 文件。
**IPC:BgWorkerShutdown**
进程正在等待后台工件关闭。
**IPC:BgWorkerStartup**
进程正在等待后台工件开启。
**IPC:BtreePage**
进程正在等待继续并行 B 树扫描所需的页码变为可用。
**IPC:CheckpointDone**
进程正在等待检查点完成。
**IPC:CheckpointStart**
进程正在等待检查点开始。
**IPC:ClogGroupUpdate**
进程正在等待组领导在事务结束时更新事务状态。
**IPC:DamRecordTxAck**
后端进程已生成数据库活动流事件，并且在等待该事件变为持久事件。有关更多信息，请参阅 [IPC:DamRecordTxAck](apg-waits.ipcdamrecordtxac.md)。
**IPC:ExecuteGather**
进程正在等待执行 Gather 计划节点时子进程中的活动。
**IPC:Hash/Batch/Allocating**
进程正在等待所选的并行哈希参与者分配哈希表。
**IPC:Hash/Batch/Electing**
进程正在选择并行哈希参与者以分配哈希表。
**IPC:Hash/Batch/Loading**
进程正在等待其他并行哈希参与者完成哈希表的加载。
**IPC:Hash/Build/Allocating**
进程正在等待所选的并行哈希参与者分配初始哈希表。
**IPC:Hash/Build/Electing**
进程正在选择并行哈希参与者以分配初始哈希表。
**IPC:Hash/Build/HashingInner**
进程正在等待其他并行哈希参与者完成内部关系的哈希。
**IPC:Hash/Build/HashingOuter**
进程正在等待其他并行哈希参与者完成外部关系的分区。
**IPC:Hash/GrowBatches/Allocating**
进程正在等待所选的并行哈希参与者分配更多批处理。
**IPC:Hash/GrowBatches/Deciding**
进程正在选择平行哈希参与者来决定未来的批处理增长。
**IPC:Hash/GrowBatches/Electing**
进程正在选择并行哈希参与者分配更多批处理。
**IPC:Hash/GrowBatches/Finishing**
进程正在等待所选的平行哈希参与者来决定未来的批处理增长。
**IPC:Hash/GrowBatches/Repartitioning**
进程正在等待其他并行哈希参与者完成重新分区。
**IPC:Hash/GrowBuckets/Allocating**
进程正在等待所选的并行哈希参与者完成更多存储桶的分配。
**IPC:Hash/GrowBuckets/Electing**
进程正在选择并行哈希参与者分配更多存储桶。
**IPC:Hash/GrowBuckets/Reinserting**
进程正在等待其他并行哈希参与者完成将元组插入到新存储桶的过程。
**IPC:HashBatchAllocate**
进程正在等待所选的并行哈希参与者分配哈希表。
**IPC:HashBatchElect**
进程正在等待选择并行哈希参与者以分配哈希表。
**IPC:HashBatchLoad**
进程正在等待其他并行哈希参与者完成哈希表的加载。
**IPC:HashBuildAllocate**
进程正在等待所选的并行哈希参与者分配初始哈希表。
**IPC:HashBuildElect**
进程正在等待选择并行哈希参与者分配初始哈希表。
**IPC:HashBuildHashInner**
进程正在等待其他并行哈希参与者完成内部关系的哈希。
**IPC:'HashBuildHashOuter**
进程正在等待其他并行哈希参与者完成外部关系的分区。
**IPC:HashGrowBatchesAllocate**
进程正在等待所选的并行哈希参与者分配更多批处理。
**IPC:'HashGrowBatchesDecide**
进程正在等待选择平行哈希参与者来决定未来的批处理增长。
**IPC:HashGrowBatchesElect**
进程正在等待选择并行哈希参与者分配更多批处理。
**IPC:HashGrowBatchesFinish**
进程正在等待所选的平行哈希参与者来决定未来的批处理增长。
**IPC:HashGrowBatchesRepartition**
进程正在等待其他并行哈希参与者完成重新分区。
**IPC:HashGrowBucketsAllocate**
进程正在等待所选的并行哈希参与者完成更多存储桶的分配。
**IPC:HashGrowBucketsElect**
进程正在等待选择并行哈希参与者分配更多存储桶。
**IPC:HashGrowBucketsReinsert**
进程正在等待其他并行哈希参与者完成将元组插入到新存储桶的过程。
**IPC:LogicalSyncData**
进程正在等待逻辑复制远程服务器发送初始表同步的数据。
**IPC:LogicalSyncStateChange**
进程正在等待逻辑复制远程服务器更改状态。
**IPC:MessageQueueInternal**
进程正在等待另进程附加到共享消息队列。
**IPC:MessageQueuePutMessage**
进程正在等待将协议消息写入共享消息队列。
**IPC:MessageQueueReceive**
进程正在等待从共享消息队列接收字节。
**IPC:MessageQueueSend**
进程正在等待将字节发送到共享消息队列。
**IPC:ParallelBitmapScan**
进程正在等待并行位图扫描初始化。
**IPC:ParallelCreateIndexScan**
进程正在等待并行 CREATE INDEX 工件完成堆扫描。
**IPC:ParallelFinish**
进程正在等待并行工件完成计算。
**IPC:ProcArrayGroupUpdate**
进程正在等待组领导在事务结束时清除事务 ID。
**IPC:ProcSignalBarrier**
进程正在等待所有后端处理障碍事件。
**IPC:Promote**
进程正在等待待机提升。
**IPC:RecoveryConflictSnapshot**
进程正在等待 vacuum 清理的恢复冲突解决方法。
**IPC:RecoveryConflictTablespace**
进程正在等待删除表空间的恢复冲突解决方法。
**IPC:RecoveryPause**
进程正在等待恢复。
**IPC:ReplicationOriginDrop**
进程正在等待复制源变为非活动状态，以便可以将其删除。
**IPC:ReplicationSlotDrop**
进程正在等待复制插槽变为非活动状态，以便可以将其删除。
**IPC:SafeSnapshot**
进程正在等待获取 READ ONLY DEFERRABLE 事务的有效快照。
**IPC:SyncRep**
进程正在同步复制期间等待来自远程服务器的确认。
**IPC:XactGroupUpdate**
进程正在等待组领导在事务结束时更新事务状态。
**Lock:advisory**
后端进程请求了一个咨询锁定并在等待它。有关更多信息，请参阅 [Lock:advisory](apg-waits.lockadvisory.md)。
**Lock:extend**
后端进程正在等待锁被释放，以便可以扩展关系。需要此锁，因为一次只有一个后端进程可以扩展关系。有关更多信息，请参阅 [Lock:extend](apg-waits.lockextend.md)。
**Lock:frozenid**
进程正在等待更新 `pg_database.datfrozenxid` 和 `pg_database.datminmxid`。
**Lock:object**
进程正在等待获取非关联数据库对象的锁定。
**Lock:page**
进程正在等待关系页面上的锁定。
**Lock:Relation**
后端进程正等待获取被另个事务锁定的关系上的锁定。有关更多信息，请参阅 [Lock:Relation](apg-waits.lockrelation.md)。
**Lock:spectoken**
进程正在等待获取推测性插入锁。
**Lock:speculative token**
进程正在等待获取推测性插入锁。
**Lock:transactionid**
一个事务正在等待行级锁定。有关更多信息，请参阅 [Lock:transactionid](apg-waits.locktransactionid.md)。
**Lock:tuple**
后端进程正在等待获取元组上的锁定，而另一个后端进程在同一个元组上保持冲突锁定。有关更多信息，请参阅 [Lock:tuple](apg-waits.locktuple.md)。
**Lock:userlock**
进程正在等待获取用户锁定。
**Lock:virtualxid**
进程正在等待获取虚拟事务 ID 锁定。
**LWLock:AddinShmemInit**
进程正在等待管理扩展在共享内存中的空间分配。
**LWLock:AddinShmemInitLock**
进程正在等待管理共享内存中的空间分配。
**LWLock:async**
进程正在等待异步（通知）缓冲区上的输入/输出。
**LWLock:AsyncCtlLock**
进程正在等待读取或更新共享通知状态。
**LWLock:AsyncQueueLock**
进程正在等待读取或更新通知消息。
**LWLock:AuroraOptimizedReadsCacheMapping**
进程正在等待将数据块与优化型读取分层缓存中的页面关联起来。
**LWLock:AutoFile**
进程正在等待更新 `postgresql.auto.conf` 文件。
**LWLock:AutoFileLock**
进程正在等待更新 `postgresql.auto.conf` 文件。
**LWLock:Autovacuum**
进程正在等待读取或更新 Autovacuum 工件的当前状态。
**LWLock:AutovacuumLock**
一个 Autovacuum 工件或启动程序正在等待更新或读取 Autovacuum 工件的当前状态。
**LWLock:AutovacuumSchedule**
进程正在等待确保选择用于 Autovacuum 的表仍然需要进行 vacuum 操作。
**LWLock:AutovacuumScheduleLock**
进程正在等待确保选择用于 vacuum 的表仍然需要进行 vacuum 操作。
**LWLock:BackendRandomLock**
进程正在等待生成一个随机数。
**LWLock:BackgroundWorker**
进程正在等待读取或更新后台工件状态。
**LWLock:BackgroundWorkerLock**
进程正在等待读取或更新后台工件状态。
**LWLock:BtreeVacuum**
进程正在等待读取或更新 B 树索引的与 vacuum 相关的信息。
**LWLock:BtreeVacuumLock**
进程正在等待读取或更新 B 树索引的与 vacuum 相关的信息。
**LWLock:buffer\$1content**
后端进程正在等待获取对共享内存缓冲区内容的轻量级锁定。有关更多信息，请参阅 [LWLock:buffer\$1content (BufferContent)](apg-waits.lockbuffercontent.md)。
**LWLock:buffer\$1mapping**
后端进程正在等待将数据块与共享缓冲池中的缓冲区关联起来。有关更多信息，请参阅 [LWLock:buffer\$1mapping](apg-waits.lwl-buffer-mapping.md)。
**LWLock:BufferIO**
后端进程想要将页面读取到共享内存中。该进程正在等待其他进程完成页面的输入/输出操作。有关更多信息，请参阅 [LWLock:BufferIO (IPC:BufferIO)](apg-waits.lwlockbufferio.md)。
**LWLock:Checkpoint**
进程正在等待开始检查点。
**LWLock:CheckpointLock**
进程正在等待执行检查点。
**LWLock:CheckpointerComm**
进程正在等待管理 `fsync` 请求。
**LWLock:CheckpointerCommLock**
进程正在等待管理 `fsync` 请求。
**LWLock:clog**
进程正在等待阻塞（事务状态）缓冲区上的输入/输出。
**LWLock:CLogControlLock**
进程正在等待读取或更新事务状态。
**LWLock:CLogTruncationLock**
进程正在等待运行 `txid_status` 或者更新可用的最早的事务 ID。
**LWLock:commit\$1timestamp**
进程正在等待提交时间戳缓冲区上的输入/输出。
**LWLock:CommitTs**
进程正在等待读取或更新为事务提交时间戳设置的最后一个值。
**LWLock:CommitTsBuffer**
进程正在等待最近使用最少的（SLRU）简单缓冲区上的输入/输出以获得提交时间戳。
**LWLock:CommitTsControlLock**
进程正在等待读取或更新事务提交时间戳。
**LWLock:CommitTsLock**
进程正在等待读取或更新为事务时间戳设置的最后一个值。
**LWLock:CommitTsSLRU**
进程正在等待访问最近使用最少的（SLRU）简单缓存以获取提交时间戳。
**LWLock:ControlFile**
进程正在等待读取或更新 `pg_control` 文件或创建新的预写日志 (WAL) 文件。
**LWLock:ControlFileLock**
进程正在等待读取或更新控制文件或创建新的预写日志 (WAL) 文件。
**LWLock:DynamicSharedMemoryControl**
进程正在等待读取或更新动态共享内存分配信息。
**LWLock:DynamicSharedMemoryControlLock**
进程正在等待读取或更新动态共享内存状态。
**LWLock:lock\$1manager**
后端进程正在等待添加或检查后端进程的锁定。或者它正在等待加入或退出由并行查询使用的锁定组。有关更多信息，请参阅 [LWLock:lock\$1manager](apg-waits.lw-lock-manager.md)。
**LWLock:LockFastPath**
进程正在等待读取或更新进程的快速路径锁定信息。
**LWLock:LogicalRepWorker**
进程正在等待读取或更新逻辑复制工件的状态。
**LWLock:LogicalRepWorkerLock**
进程正在等待对逻辑复制工件的操作完成。
**LWLock:LogicalSchemaCache**
一个进程修改了架构缓存。
**LWLock:multixact\$1member**
进程正在等待 multixact\$1member 缓冲区上的输入/输出。
**LWLock:multixact\$1offset**
进程正在等待 multixact offset 缓冲区上的输入/输出。
**LWLock:MultiXactGen**
进程正在等待读取或更新共享 multixact 状态。
**LWLock:MultiXactGenLock**
进程正在等待读取或更新共享 multixact 状态。
**LWLock:MultiXactMemberBuffer**
进程正在等待 multixact 成员的最近使用最少的（SLRU）简单缓冲区上的输入/输出。有关更多信息，请参阅 [LWLock:MultiXact](apg-waits.lwlockmultixact.md)。
**LWLock:MultiXactMemberControlLock**
进程正在等待读取或更新 multixact 成员映射。
**LWLock:MultiXactMemberSLRU**
进程正在等待访问 multixact 成员的最近使用最少的（SLRU）简单缓存。有关更多信息，请参阅 [LWLock:MultiXact](apg-waits.lwlockmultixact.md)。
**LWLock:MultiXactOffsetBuffer**
进程正在等待 multixact offset 的最近使用最少的（SLRU）简单缓冲区上的输入/输出。有关更多信息，请参阅 [LWLock:MultiXact](apg-waits.lwlockmultixact.md)。
**LWLock:MultiXactOffsetControlLock**
进程正在等待读取或更新 multixact offset 映射。
**LWLock:MultiXactOffsetSLRU**
进程正在等待访问 multixact offset 的最近使用最少的（SLRU）简单缓存。有关更多信息，请参阅 [LWLock:MultiXact](apg-waits.lwlockmultixact.md)。
**LWLock:MultiXactTruncation**
进程正在等待读取或截断 multixact 信息。
**LWLock:MultiXactTruncationLock**
进程正在等待读取或截断 multixact 信息。
**LWLock:NotifyBuffer**
进程正在等待 NOTIFY 消息的最近使用最少的（SLRU）简单缓冲区上的输入/输出。
**LWLock:NotifyQueue**
进程正在等待读取或更新 NOTIFY 消息。
**LWLock:NotifyQueueTail**
进程正在等待更新 NOTIFY 消息存储的限制。
**LWLock:NotifyQueueTailLock**
进程正在等待更新通知消息存储的限制。
**LWLock:NotifySLRU**
进程正在等待访问 NOTIFY 消息的最近使用最少的（SLRU）简单缓存。
**LWLock:OidGen**
进程正在等待分配新的对象 ID (OID)。
**LWLock:OidGenLock**
进程正在等待分配或指派对象 ID (OID)。
**LWLock:oldserxid**
进程正在等待 oldserxid 缓冲区上的输入/输出。
**LWLock:OldSerXidLock**
进程正在等待读取或记录冲突的可序列化事务。
**LWLock:OldSnapshotTimeMap**
进程正在等待读取或更新旧的快照控制信息。
**LWLock:OldSnapshotTimeMapLock**
进程正在等待读取或更新旧的快照控制信息。
**LWLock:parallel\$1append**
进程在并行追加计划执行期间正在等待选择下一个子计划。
**LWLock:parallel\$1hash\$1join**
进程在并行哈希计划执行期间正在等待分配或交换一块内存或更新计数器。
**LWLock:parallel\$1query\$1dsa**
进程正在等待锁定并行查询的动态共享内存分配。
**LWLock:ParallelAppend**
进程在并行追加计划执行期间正在等待选择下一个子计划。
**LWLock:ParallelHashJoin**
进程在计划执行期间正在等待同步工件以进行并行哈希联接。
**Lwlock:ParallelQueryDSA**
进程正在等待并行查询的动态共享内存分配。
**Lwlock:PerSessionDSA**
进程正在等待并行查询的动态共享内存分配。
**Lwlock:PerSessionRecordType**
进程正在等待访问并行查询有关复合类型的信息。
**Lwlock:PerSessionRecordTypmod**
进程正在等待访问有关识别匿名记录类型的类型修饰符的并行查询的信息。
**Lwlock:PerXactPredicateList**
进程在并行查询期间正在等待访问当前可序列化事务所持有的谓词锁定的列表。
**Lwlock:predicate\$1lock\$1manager**
进程正在等待添加或检查谓词锁定信息。
**Lwlock:PredicateLockManager**
进程正在等待访问可序列化事务使用的谓词锁定信息。
**Lwlock:proc**
进程正在等待读取或更新快速路径锁定信息。
**LWLock:ProcArray**
进程正在等待访问共享的每个进程的数据结构（通常是获取快照或报告会话的事务 ID
**LWLock:ProcArrayLock**
进程正在等待获取快照或在事务结束时清除事务 ID。
**LWLock:RelationMapping**
进程正在等待读取或更新 `pg_filenode.map` 文件（用于跟踪某些系统目录的文件节点分配）。
**LWLock:RelationMappingLock**
进程正在等待更新用于存储目录到文件节点映射的关系映射文件。
**LWLock:RelCacheInit**
进程正在等待读取或更新 `pg_internal.init` 文件（关系缓存初始化文件）。
**LWLock:RelCacheInitLock**
进程正在等待读取或写入关系缓存初始化文件。
**LWLock:replication\$1origin**
进程正在等待读取或更新复制进度。
**LWLock:replication\$1slot\$1io**
进程正在等待复制插槽上的输入/输出。
**LWLock:ReplicationOrigin**
进程正在等待创建、删除或使用复制源。
**LWLock:ReplicationOriginLock**
进程正在等待设置、删除或使用复制源。
**LWLock:ReplicationOriginState**
进程正在等待读取或更新一个复制源的进度。
**LWLock:ReplicationSlotAllocation**
进程正在等待分配或释放复制插槽。
**LWLock:ReplicationSlotAllocationLock**
进程正在等待分配或释放复制插槽。
**LWLock:ReplicationSlotControl**
进程正在等待读取或更新复制插槽状态。
**LWLock:ReplicationSlotControlLock**
进程正在等待读取或更新复制插槽状态。
**LWLock:ReplicationSlotIO**
进程正在等待复制插槽上的输入/输出。
**LWLock:SerialBuffer**
进程正在等待可序列化事务冲突的最近使用最少的（SLRU）简单缓冲区上的输入/输出。
**LWLock:SerializableFinishedList**
进程正在等待访问已完成的可序列化事务的列表。
**LWLock:SerializableFinishedListLock**
进程正在等待访问已完成的可序列化事务的列表。
**LWLock:SerializablePredicateList**
进程正在等待访问可序列化事务所持有的谓词锁定的列表。
**LWLock:SerializablePredicateLockListLock**
进程正在等待对可序列化事务持有的锁定的列表执行操作。
**LWLock:SerializableXactHash**
进程正在等待读取或更新有关可序列化事务的信息。
**LWLock:SerializableXactHashLock**
进程正在等待读取或更新有关可序列化事务的信息。
**LWLock:SerialSLRU**
进程正在等待访问可序列化事务冲突的最近使用最少的（SLRU）简单缓存。
**LWLock:SharedTidBitmap**
进程在并行位图索引扫描期间正在等待访问共享元组标识符 (TID) 位图。
**LWLock:SharedTupleStore**
进程在并行查询期间正在等待访问共享元组存储。
**LWLock:ShmemIndex**
进程正在等待查找或分配共享内存中的空间。
**LWLock:ShmemIndexLock**
进程正在等待查找或分配共享内存中的空间。
**LWLock:SInvalRead**
进程正在等待从共享目录失效队列中检索消息。
**LWLock:SInvalReadLock**
进程正在等待从共享失效队列中检索或移除消息。
**LWLock:SInvalWrite**
进程正在等待向共享目录失效队列中添加消息。
**LWLock:SInvalWriteLock**
进程正在等待在共享失效队列中添加消息。
**LWLock:SyncRep**
进程正在等待读取或更新有关同步复制状态的信息。
**LWLock:SyncRepLock**
进程正在等待读取或更新有关同步副本的信息。
**LWLock:SyncScan**
进程正在等待选择同步表扫描的起始位置。
**LWLock:SyncScanLock**
进程正在等待获取一个扫描在同步扫描表上的起始位置。
**LWLock:TablespaceCreate**
进程正在等待创建或删除表空间。
**LWLock:TablespaceCreateLock**
进程正在等待创建或删除表空间。
**LWLock:tbm**
进程正在等待树位图 (TBM) 上的共享迭代器锁定。
**LWLock:TwoPhaseState**
进程正在等待读取或更新准备好的事务的状态。
**LWLock:TwoPhaseStateLock**
进程正在等待读取或更新准备好的事务的状态。
**LWLock:wal\$1insert**
进程正在等待将预写日志 (WAL) 插入内存缓冲区。
**LWLock:WALBufMapping**
进程正在等待替换预写日志 (WAL) 缓冲区中的页面。
**LWLock:WALBufMappingLock**
进程正在等待替换预写日志 (WAL) 缓冲区中的页面。
**LWLock:WALInsert**
进程正在等待将预写日志 (WAL) 数据插入内存缓冲区。
**LWLock:WALWrite**
进程正等待将预写日志 (WAL) 缓冲区写入磁盘。
**LWLock:WALWriteLock**
进程正等待将预写日志 (WAL) 缓冲区写入磁盘。
**LWLock:WrapLimitsVacuum**
进程正在等待更新事务 ID 和 multixact 消耗量的限制。
**LWLock:WrapLimitsVacuumLock**
进程正在等待更新事务 ID 和 multixact 消耗量的限制。
**LWLock:XactBuffer**
进程正在等待事务状态的最近使用最少的（SLRU）简单缓冲区上的输入/输出。
**LWLock:XactSLRU**
进程正在等待访问事务状态的最近使用最少的（SLRU）简单缓存。
**LWLock:XactTruncation**
进程正在等待运行 pg\$1xact\$1status 或者更新可用的最早的事务 ID。
**LWLock:XidGen**
进程正在等待分配新的事务 ID。
**LWLock:XidGenLock**
进程正在等待分配或指派事务 ID。
**Timeout:BaseBackupThrottle**
限制活动时，进程正在基本备份期间等待。
**Timeout:PgSleep**
后端进程已调用 pg\$1sleep 函数，正在等待睡眠超时过期。有关更多信息，请参阅 [Timeout:PgSleep](apg-waits.timeoutpgsleep.md)。
**Timeout:RecoveryApplyDelay**
由于延迟设置，进程正等待在恢复期间应用预写日志 (WAL)。
**Timeout:RecoveryRetrieveRetryInterval**
当没有来自任何来源（pg\$1wal、存档或流）的预写日志 (WAL) 数据时，进程在恢复过程中等待。
**Timeout:VacuumDelay**
进程正在基于成本的 vacuum 延迟点等待。
有关 PostgreSQL 等待事件的完整列表，请参阅 PostgreSQL 文档中的[统计数据收集器 > 等待事件表](https://www.postgresql.org/docs/current/monitoring-stats.html#WAIT-EVENT-TABLE)。