Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Amazon-Aurora-PostgreSQL-Referenz
In den folgenden Themen finden Sie Informationen über Kollationen, Funktionen, Parameter und Warteereignisse in Amazon Aurora PostgreSQL.
**Topics**
+ [Aurora-PostgreSQL-Kollationen für EBCDIC- und andere Mainframe-Migrationen](#AuroraPostgreSQL.Reference.Collations.mainframe.migration)
+ [](PostgreSQL-Collations.md)
+ [Aurora-PostgreSQL-Funktionsreferenz](Appendix.AuroraPostgreSQL.Functions.md)
+ [Amazon-Aurora-PostgreSQL-Parameter](AuroraPostgreSQL.Reference.ParameterGroups.md)
+ [Amazon-Aurora-PostgreSQL-Warteereignisse](AuroraPostgreSQL.Reference.Waitevents.md)
## Aurora-PostgreSQL-Kollationen für EBCDIC- und andere Mainframe-Migrationen
Migration von Mainframe-Anwendungen auf neue Plattformen wie AWS bewahrt idealerweise das Anwendungsverhalten. Damit das Anwendungsverhalten auf einer neuen Plattform genauso erhalten bleibt, wie es auf dem Mainframe war, müssen migrierte Daten mit denselben Kollations- und Sortierregeln zusammengetragen werden. Beispielsweise verschieben viele Db2-Migrationslösungen Nullwerte auf u0180 (Unicode-Position 0180), sodass diese Sortierungen zuerst u0180 sortieren. Dies ist ein Beispiel dafür, wie Kollationen von ihrer Mainframe-Quelle abweichen können und warum es notwendig ist, eine Kollation zu wählen, die besser der ursprünglichen EBCDIC-Kollation entspricht.
Aurora PostgreSQL 14.3 und höhere Versionen bieten viele ICU- und EBCDIC-Kollationen, um eine solche Migration nach AWS unter Verwendung der AWS-Mainframe-Modernisierung zu unterstützen. Weitere Informationen zu diesem Service finden Sie unter [Was ist AWS Mainframe-Modernisierung?](https://docs.aws.amazon.com/m2/latest/userguide/what-is-m2.html)
In der folgenden Tabelle finden Sie von Aurora PostgreSQL bereitgestellte Sortierungen. Diese Sortierungen folgen den EBCDIC-Regeln und stellen sicher, dass Mainframe-Anwendungen auf dieselbe Weise auf AWS funktionieren, wie sie es in der Mainframe-Umgebung getan haben. Der Kollationsname beinhaltet die entsprechende Codepage, (cp*nnnn*), sodass Sie die passende Sortierung für Ihre Mainframe-Quelle auswählen können. Verwenden Sie z. B. `en-US-cp037-x-icu`, um das Kollationsverhalten für EBCDIC-Daten zu erreichen, die von einer Mainframe-Anwendung stammen, die Codepage 037 verwendete.
| EBCDIC-Kollationen | AWS Blue Age | AWS Micro-Focus-Kollationen |
| --- | --- | --- |
| 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 | – |
Weitere Informationen über AWS Blu Age finden Sie im [Tutorial: Verwaltete Runtime für AWS Blu Age](https://docs.aws.amazon.com/m2/latest/userguide/tutorial-runtime-ba.html) im *AWSMainframe-Modernisierung-Benutzerhandbuch*.
Weitere Informationen zur Arbeit mit AWS Mikrofokus finden Sie im [Tutorial: Verwaltete Runtime für Micro Focus](https://docs.aws.amazon.com/m2/latest/userguide/tutorial-runtime.html) im *AWS-Mainframe-Modernisierung-Benutzerhandbuch*.
Weitere Informationen zu PostgreSQL und Kollationen finden Sie unter [Support für Kollationen](https://www.postgresql.org/docs/current/collation.html) in der PostgreSQL-Dokumentation.
#
Sortierungen sind eine Reihe von Regeln, die bestimmen, wie in der Datenbank gespeicherte Zeichenfolgen sortiert und verglichen werden. Sortierungen spielen eine grundlegende Rolle im Computersystem und sind Teil des Betriebssystems. Sortierungen ändern sich im Laufe der Zeit, wenn neue Zeichen zu Sprachen hinzugefügt werden oder wenn sich die Sortierregeln ändern.
Sortierungsbibliotheken definieren spezifische Regeln und Algorithmen für eine Sortierung. Die beliebtesten Sortierungsbibliotheken, die in PostgreSQL verwendet werden, sind GNU C (glibc) und Internationalization Components for Unicode (ICU). Standardmäßig verwendet Aurora PostgreSQL die Glibc-Sortierung, die Unicode-Zeichensortierreihenfolgen für Multibyte-Zeichensequenzen enthält.
Wenn Sie einen neuen DB-Cluster von Aurora PostgreSQL erstellen, wird das Betriebssystem auf die verfügbare Sortierung überprüft. Die PostgreSQL-Parameter des `CREATE DATABASE`-Befehls `LC_COLLATE` und `LC_CTYPE` werden verwendet, um eine Sortierung anzugeben, die in dieser Datenbank als Standardsortierung gilt. Alternativ können Sie auch den Parameter `LOCALE` in `CREATE DATABASE` verwenden, um diese Parameter festzulegen. Dieser bestimmt die Standardsortierung für Zeichenfolgen in der Datenbank und die Regeln für die Klassifizierung von Zeichen als Buchstaben, Zahlen oder Symbole. Sie können auch eine Sortierung auswählen, die für eine Spalte, einen Index oder eine Abfrage verwendet werden soll.
Aurora PostgreSQL benötigt für die Sortierungsunterstützung die Glibc-Bibliothek im Betriebssystem. Die Instance von Aurora PostgreSQL wird regelmäßig mit den neuesten Versionen des Betriebssystems aktualisiert. Diese Updates umfassen manchmal eine neuere Version der Glibc-Bibliothek. In seltenen Fällen ändern neuere Versionen von Glibc die Sortierreihenfolge oder Sortierung einiger Zeichen, was dazu führen kann, dass die Daten anders sortiert werden oder ungültige Indexeinträge entstehen. Wenn Sie während eines Updates bei der Sortierung Probleme mit der Sortierreihenfolge feststellen, müssen Sie möglicherweise die Indizes neu erstellen.
Damit mögliche Auswirkungen der Glibc-Updates reduziert werden, enthält Aurora PostgreSQL jetzt eine unabhängige Standard-Sortierungsbibliothek. Diese Sortierungsbibliothek ist in Aurora PostgreSQL 14.6, 13.9, 12.13, 11.18 und neueren Nebenversionen verfügbar. Sie ist mit Glibc 2.26-59.amzn2 kompatibel und bietet eine stabile Sortierreihenfolge, um falsche Abfrageergebnisse zu verhindern.
# Aurora-PostgreSQL-Funktionsreferenz
Nachfolgend finden Sie eine Liste der Aurora PostgreSQL-Funktionen, die für Ihre Aurora-DB-Cluster verfügbar sind, welche die Aurora PostgreSQL-kompatible Edition-DB-Engine ausführen. Diese Aurora PostgreSQL-Funktionen sind zusätzlich zu den Standard-PostgreSQL-Funktionen. Weitere Informationen zu PostgreSQL-Standardfunktionen finden Sie unter [PostgreSQL – Funktionen und Operatoren](https://www.postgresql.org/docs/current/functions.html).
## -Übersicht
Sie können die folgenden Funktionen für Amazon-RDS-DB-Instances verwenden, auf denen Aurora PostgreSQL ausgeführt wird:
+ [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\$1waits](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
Meldet den Namen der DB-Instance, mit der Sie verbunden sind.
## Syntax
```
aurora_db_instance_identifier()
```
## Argumente
Keine
## Rückgabetyp
VARCHAR-Zeichenfolge
## Nutzungshinweise
Diese Funktion zeigt den Namen der DB-Instance des Aurora-PostgreSQL-kompatiblen Edition-Clusters für Ihre Datenbank-Client- oder Anwendungsverbindung an.
Diese Funktion ist ab der Veröffentlichung der PostgreSQL-Versionen 13.7, 12.11, 11.16 und 10.21 und für alle späteren Versionen verfügbar.
## Beispiele
Im folgenden Beispiel sehen Sie die Ergebnisse vom Aufruf der Funktion `aurora_db_instance_identifier`.
```
=> SELECT aurora_db_instance_identifier();
aurora_db_instance_identifier
-------------------------------
test-my-instance-name
```
Sie können die Ergebnisse dieser Funktion mit der `aurora_replica_status`-Funktion verbinden, um Details über die DB-Instance für Ihre Verbindung abzurufen. Die [aurora\$1replica\$1status](aurora_replica_status.md) allein zeigt Ihnen nicht, welche DB-Instance Sie verwenden. Im folgenden Beispiel wird gezeigt, wie Sie dies tun.
```
=> 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
Zeigt den Status des Cluster-Cache-Managers an.
## Syntax
```
aurora_ccm_status()
```
## Argumente
Keine.
## Rückgabetyp
SETOF-Datensatz mit den folgenden Spalten:
+ `buffers_sent_last_minute` – Die Anzahl der Puffer, die in der letzten Minute an den designierten Reader gesendet wurden.
+ `buffers_found_last_minute` – Die Anzahl der Puffer, auf die in der letzten Minute häufig zugegriffen wurde.
+ `buffers_sent_last_scan` – Die Anzahl der Puffer, die während des letzten vollständigen Scanvorgangs des Puffercaches an den designierten Reader gesendet wurden.
+ `buffers_found_last_scan` – Die Anzahl der Puffer, auf die während des letzten vollständigen Scanvorgangs des Puffercaches häufig zugegriffen wurde. Puffer, die bereits im Cache des designierten Readers abgelegt wurden, werden nicht gesendet.
+ `buffers_sent_current_scan` – Die Anzahl der Puffer, die während des aktuellen Scanvorgangs gesendet wurden.
+ `buffers_found_current_scan` – Die Anzahl der häufig aufgerufenen Puffer, die im aktuellen Scan identifiziert wurden.
+ `current_scan_progress` – Die Anzahl der Puffer, die während des aktuellen Scanvorgangs aufgerufen wurden.
## Nutzungshinweise
Sie können diese Funktion verwenden, um die Funktion zur Cluster-Cache-Verwaltung (CCM) zu überprüfen und zu überwachen. Diese Funktion ist nur verfügbar, wenn CCM auf Ihrem Aurora-PostgreSQL-DB-Cluster aktiv ist. Zum Verwenden dieser Funktion stellen Sie eine Verbindung mit der Write-DB-Instance Ihres Aurora-PostgreSQL-DB-Clusters her.
Sie aktivieren CCM für einen Aurora-PostgreSQL-DB-Cluster, indem Sie den Wert `apg_ccm_enabled` in der benutzerdefinierten DB-Cluster-Parametergruppe des Clusters auf 1 festlegen. Um zu erfahren wie dies geht, vgl. [Konfigurieren der Cluster-Cache-Verwaltung](AuroraPostgreSQL.cluster-cache-mgmt.md#AuroraPostgreSQL.cluster-cache-mgmt.Configure).
Die Cluster-Cache-Verwaltung ist auf einem Aurora-PostgreSQL-DB-Cluster aktiv, wenn der Cluster über eine Aurora-Reader-Instance verfügt, die wie folgt konfiguriert ist:
+ Die Aurora-Reader-Instance verwendet den gleichen Typ und die gleiche Größe der DB-Instance-Klasse wie die Writer-Instance des Clusters.
+ Die Aurora-Reader-Instance ist für den Cluster als Tier-0 konfiguriert. Wenn der Cluster über mehr als einen Reader verfügt, ist dies der einzige Tier-0-Reader.
Wenn Sie mehr als einen Reader auf Tier-0 einstellen, wird CCM deaktiviert. Wenn CCM deaktiviert ist, wird beim Aufruf dieser Funktion die folgende Fehlermeldung zurückgegeben:
```
ERROR: Cluster Cache Manager is disabled
```
Sie können auch die PostgreSQL-Erweiterung pg\$1buffercache verwenden, um den Puffercache zu analysieren. Weitere Informationen finden Sie unter [pg\$1buffercache](https://www.postgresql.org/docs/current/pgbuffercache.html) in der PostgreSQL-Dokumentation.
Weitere Informationen finden Sie unter [Einführung in die Aurora-PostgreSQL-Cluster-Cache-Verwaltung](https://aws.amazon.com/blogs/database/introduction-to-aurora-postgresql-cluster-cache-management/).
## Beispiele
Im folgenden Beispiel sehen Sie die Ergebnisse vom Aufruf der Funktion `aurora_ccm_status`. Dieses erste Beispiel zeigt CCM-Statistiken.
```
=> 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
```
Für ausführlichere Details können Sie die erweiterte Anzeige verwenden, wie im Folgenden gezeigt:
```
\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
```
Dieses Beispiel zeigt, wie die aktive Rate und der aktive Prozentsatz überprüft werden.
```
=> 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
Zeigt den Status aller Aurora-Instances an, einschließlich Replikaten in einem globalen Aurora-DB-Cluster.
## Syntax
```
aurora_global_db_instance_status()
```
## Argumente
Keine
## Rückgabetyp
SETOF-Datensatz mit den folgenden Spalten:
+ `server_id` – Die ID der DB-Instance.
+ `session_id` – Eindeutiger Bezeichner für die aktuelle Sitzung. Der Wert `MASTER_SESSION_ID` bezeichnet die (primäre) Writer-DB-Instance.
+ `aws_region` – Die AWS-Region, in der diese globale DB-Instance ausgeführt wird. Eine Liste der Regionen finden Sie unter [Verfügbarkeit in Regionen](Concepts.RegionsAndAvailabilityZones.md#Aurora.Overview.Availability).
+ `durable_lsn` – Die Log-Sequenznummer (LSN), die dauerhaft gespeichert wurde. Eine Log-Sequenznummer (LSN) ist eine eindeutige fortlaufende Nummer, die einen Datensatz im Datenbank-Transaktionsprotokoll identifiziert. LSNs werden so angeordnet, dass eine größere LSN eine spätere Transaktion darstellt.
+ `highest_lsn_rcvd` – Die höchste LSN, die die DB-Instance von der Writer-DB-Instance empfangen hat.
+ `feedback_epoch` – Die Epoche, die die DB-Instance beim Erzeugen der Hot-Standby-Informationen verwendet. Ein *Hot Standby* ist eine DB-Instance, die Verbindungen und Abfragen unterstützt, während sich die primäre DB im Wiederherstellungs- oder Standby-Modus befindet. Die Hot-Standby-Informationen umfassen die Epoche (bestimmter Zeitpunkt) und andere Details über die DB-Instance, die als Hot-Standby verwendet wird. Weitere Informationen finden Sie in der PostgreSQL-Dokumentation zu [Hot Standby](https://www.postgresql.org/docs/current/hot-standby.html).
+ `feedback_xmin` – Die minimale (älteste) aktive Transaktions-ID, die von der DB-Instance verwendet wird.
+ `oldest_read_view_lsn` – Die älteste LSN, die von der DB-Instance zum Lesen aus dem Speicher verwendet wird.
+ `visibility_lag_in_msec` – Gibt an (in Millisekunden), wie weit die DB-Instance hinter der Writer-DB-Instance zurückgeblieben ist.
## Nutzungshinweise
Diese Funktion gibt Aufschluss über Replikationsstatistiken für einen Aurora-DB-Cluster. Für jede Aurora-PostgreSQL-DB-Instance im Cluster zeigt die Funktion eine Datenreihe an, die regionsübergreifende Replikate in einer globalen Datenbankkonfiguration enthält.
Sie können diese Funktion von jeder Instance in einem Aurora-PostgreSQL-DB-Cluster oder einer globalen Aurora-PostgreSQL-Datenbank ausführen. Die Funktion gibt Details zur Verzögerung für alle Replikat-Instances zurück.
Weitere Informationen über die Überwachung der Verzögerung mithilfe dieser Funktion (`aurora_global_db_instance_status`) oder mit `aurora_global_db_status` finden Sie unter [Überwachen von Aurora-PostgreSQL-basierten globalen Datenbanken](aurora-global-database-monitoring.md#aurora-global-database-monitoring.postgres).
Informationen über globale Aurora-Datenbanken finden Sie unter [Übersicht über Amazon Aurora Global Database](aurora-global-database.md#aurora-global-database-overview).
Informationen zu den ersten Schritten mit globalen Aurora-Datenbanken finden Sie unter [Erste Schritte mit Amazon Aurora Global Database](aurora-global-database-getting-started.md) oder [Häufig gestellte Fragen zu Amazon Aurora](https://aws.amazon.com/rds/aurora/faqs/).
## Beispiele
Dieses Beispiel zeigt regionsübergreifende Instance-Statistiken.
```
=> 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
```
Dieses Beispiel veranschaulicht, wie die globale Replikatverzögerung in Millisekunden überprüft wird.
```
=> 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
```
Dieses Beispiel zeigt, wie die minimale, maximale und durchschnittliche Verzögerung je AWS-Region im Hinblick auf die globale Datenbankkonfiguration überprüft wird.
```
=> 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
Zeigt Informationen über verschiedene Aspekte der globalen Aurora-Datenbankverzögerung an, insbesondere die Verzögerung des zugrunde liegenden Aurora-Speichers (sogenannte Haltbarkeitsverzögerung) und die Verzögerung zwischen dem Recovery Point Objective (RPO).
## Syntax
```
aurora_global_db_status()
```
## Argumente
Keine.
## Rückgabetyp
SETOF-Datensatz mit den folgenden Spalten:
+ `aws_region` – Die AWS-Region, in der sich dieser DB-Cluster befindet. Eine vollständige Auflistung von AWS-Regionen nach Engine finden Sie unter [ Regionen und Availability Zones](Concepts.RegionsAndAvailabilityZones.md).
+ `highest_lsn_written` – Die höchste Log-Sequenznummer (LSN), die derzeit auf diesem DB-Cluster vorhanden ist. Eine Log-Sequenznummer (LSN) ist eine eindeutige fortlaufende Nummer, die einen Datensatz im Datenbank-Transaktionsprotokoll identifiziert. LSNs werden so angeordnet, dass eine größere LSN eine spätere Transaktion darstellt.
+ `durability_lag_in_msec` – Die Differenz zwischen den Zeitstempelwerten der `highest_lsn_written` auf einem sekundären DB-Cluster und der `highest_lsn_written` auf dem primären DB-Cluster. Der Wert -1 identifiziert den primären DB-Cluster der globalen Aurora-Datenbank.
+ `rpo_lag_in_msec` – Die RPO-Verzögerung (Recovery Point Objective). Die RPO-Verzögerung ist die Zeit, die benötigt wird, bis die letzte Benutzertransaktion COMMIT auf einem sekundären DB-Cluster gespeichert wird, nachdem sie auf dem primären DB-Cluster einer globalen Aurora-Datenbank abgelegt wurde. Der Wert -1 bezeichnet den primären DB-Cluster (die Verzögerung ist daher nicht relevant).
Einfach ausgedrückt berechnet diese Metrik das Recovery Point Objective für jeden Aurora-PostgreSQL-DB-Cluster in der globalen Aurora-Datenbank, d. h., wie viele Daten bei einem Ausfall verloren gehen könnten. Wie die Verzögerung wird auch RPO zeitlich gemessen.
+ `last_lag_calculation_time` – Der Zeitstempel, der angibt, wann die Werte für `durability_lag_in_msec` und `rpo_lag_in_msec` zuletzt berechnet wurden. Ein Zeitwert wie `1970-01-01 00:00:00+00` bedeutet, dass dies der primäre DB-Cluster ist.
+ `feedback_epoch` – Die Epoche, die der sekundäre DB-Cluster beim Erzeugen von Hot-Standby-Informationen verwendet. Ein *Hot Standby* ist eine DB-Instance, die Verbindungen und Abfragen unterstützt, während sich die primäre DB im Wiederherstellungs- oder Standby-Modus befindet. Die Hot-Standby-Informationen umfassen die Epoche (bestimmter Zeitpunkt) und andere Details über die DB-Instance, die als Hot-Standby verwendet wird. Weitere Informationen finden Sie in der PostgreSQL-Dokumentation zu [Hot Standby](https://www.postgresql.org/docs/current/hot-standby.html).
+ `feedback_xmin` – Die minimale (älteste) aktive Transaktions-ID, die von einem sekundären DB-Cluster verwendet wird.
## Nutzungshinweise
Alle derzeit verfügbaren Aurora-PostgreSQL-Versionen unterstützen diese Funktion. Diese Funktion zeigt Replikationsstatistiken für eine globale Aurora-Datenbank. Sie zeigt eine Zeile für jeden DB-Cluster in einer globalen Aurora-PostgreSQL-Datenbank. Sie können diese Funktion von jeder Instance in Ihrer globalen Aurora-PostgreSQL-Datenbank ausführen.
Informationen zur Auswertung der Replikationsverzögerung der globalen Aurora-Datenbank, die die sichtbare Datenverzögerung darstellt, finden Sie unter [aurora\$1global\$1db\$1instance\$1status](aurora_global_db_instance_status.md).
Weitere Informationen über die Verwendung von `aurora_global_db_status` und `aurora_global_db_instance_status` zur Überwachung der globalen Aurora-Datenbankverzögerung finden Sie unter [Überwachen von Aurora-PostgreSQL-basierten globalen Datenbanken](aurora-global-database-monitoring.md#aurora-global-database-monitoring.postgres). Informationen über globale Aurora-Datenbanken finden Sie unter [Übersicht über Amazon Aurora Global Database](aurora-global-database.md#aurora-global-database-overview).
## Beispiele
Dieses Beispiel zeigt, wie regionsübergreifende Speicherstatistiken angezeigt werden.
```
=> 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
Listet alle verfügbaren integrierten Aurora-PostgreSQL-Funktionen mit kurzen Beschreibungen und Funktionsdetails auf.
## Syntax
```
aurora_list_builtins()
```
## Argumente
Keine
## Rückgabetyp
SETOF-Datensatz
## Beispiele
Im folgenden Beispiel sehen Sie Ergebnisse vom Aufruf der Funktion `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
Zeigt den Status aller Aurora-PostgreSQL-Reader-Knoten an.
## Syntax
```
aurora_replica_status()
```
## Argumente
Keine
## Rückgabetyp
SETOF-Datensatz mit den folgenden Spalten:
+ `server_id` – Die DB-Instance-ID (Kennung).
+ `session_id` – Eine eindeutige ID für die aktuelle Sitzung, die wie folgt für die primäre Instance und Reader-Instances zurückgegeben wird:
+ Für die primäre Instance ist `session_id` immer ``MASTER_SESSION_ID’`.
+ Für Reader-Instances ist `session_id` immer die `UUID` (Universally Unique Identifier, eindeutige Kennung) der Reader-Instance.
+ `durable_lsn` – Die Log-Sequenznummer (LSN), die im Speicher abgelegt wurde.
+ Für das primäre Volume die dauerhafte LSN des primären Volumes (VDL), die derzeit in Kraft ist.
+ Für alle sekundären Volumes die VDL des primären Volumes, auf das das sekundäre Volume erfolgreich angewendet wurde.
**Anmerkung**
Eine Log-Sequenznummer (LSN) ist eine eindeutige fortlaufende Nummer, die einen Datensatz im Datenbank-Transaktionsprotokoll identifiziert. LSNs werden so angeordnet, dass eine größere LSN eine Transaktion darstellt, die später in der Sequenz auftritt.
+ `highest_lsn_rcvd` – Die höchste (neueste) LSN, die die DB-Instance von der Writer-DB-Instance empfangen hat.
+ `current_read_lsn` – Die LSN des letzten Snapshots, die auf alle Reader angewendet wurde.
+ `cur_replay_latency_in_usec` – Die Anzahl der Mikrosekunden, die voraussichtlich benötigt werden, um das Protokoll auf der sekundären Instance wiederzugeben.
+ `active_txns` – Die Anzahl der derzeit aktiven Transaktionen.
+ `is_current` – Nicht verwendet.
+ `last_transport_error` – Fehlercode für die letzte Replikation.
+ `last_error_timestamp` – Zeitstempel des letzten Replikationsfehlers.
+ `last_update_timestamp` – Zeitstempel der letzten Aktualisierung auf den Replikatstatus. Ab Aurora PostgreSQL 13.9 ist der `last_update_timestamp`-Wert für die DB-Instance, mit der Sie verbunden sind, auf `NULL` festgelegt.
+ `feedback_xmin` – Der Hot Standby feedback\$1xmin des Replikats. Die minimale (älteste) aktive Transaktions-ID, die von der DB-Instance verwendet wird.
+ `feedback_epoch` – Die Epoche, die die DB-Instance beim Erzeugen der Hot-Standby-Informationen verwendet.
+ `replica_lag_in_msec` – Zeit, die die Leser-Instance in Millisekunden hinter der Schreiber-Instance zurückbleibt
+ `log_stream_speed_in_kib_per_second` – Der Durchsatz des Protokollstreams in Kilobyte pro Sekunde.
+ `log_buffer_sequence_number` – Die Sequenznummer des Protokollpuffers.
+ `oldest_read_view_trx_id` – Nicht verwendet.
+ `oldest_read_view_lsn` – Die älteste LSN, die von der DB-Instance zum Lesen aus dem Speicher verwendet wird.
+ `pending_read_ios` – Die ausstehenden Seiten-Lesevorgänge, die noch im Replikat anstehen.
+ `read_ios` – Die Gesamtzahl der Lesevorgänge auf dem Replikat.
+ `iops` – Nicht verwendet.
+ `cpu` – CPU-Auslastung des Aurora-Speicher-Daemon für jeden Knoten im Cluster. Weitere Informationen zur CPU-Auslastung durch die Instance finden Sie unter [Metriken auf Instance-Ebene für Amazon Aurora](Aurora.AuroraMonitoring.Metrics.md#Aurora.AuroraMySQL.Monitoring.Metrics.instances).
## Nutzungshinweise
Alle derzeit verfügbaren Aurora-PostgreSQL-Versionen unterstützen diese Funktion. Die Funktion `aurora_replica_status` gibt Werte aus dem Replikatstatus-Manager eines Aurora-PostgreSQL-DB-Clusters zurück. Sie können diese Funktion verwenden, um Informationen über den Status der Replikation auf Ihrem Aurora-PostgreSQL-DB-Cluster zu erhalten, einschließlich Metriken für alle DB-Instances in Ihrem Aurora-DB-Cluster. Sie können z. B. Folgendes tun:
+ **Informationen über die Art der Instance (Writer, Reader) im Aurora-PostgreSQL-DB-Cluster abrufen** – Diese Informationen erhalten Sie, indem Sie sich die Werte der folgenden Spalten ansehen:
+ `server_id` – Enthält den Namen der Instance, die Sie beim Erstellen der Instance festgelegt haben. In einigen Fällen, z. B. für die primäre (Writer-)Instance, wird der Name normalerweise durch Anhängen von *-instance-1* an den Namen, den Sie für Ihren Aurora-PostgreSQL-DB-Cluster festlegen, für Sie erstellt.
+ `session_id` – Das Feld `session_id` gibt an, ob es sich bei der Instance um einen Reader oder einen Writer handelt. Für eine Writer-Instance ist `session_id` immer auf `"MASTER_SESSION_ID"` festgelegt. Für eine Reader-Instance ist `session_id` auf die `UUID` des spezifischen Readers festgelegt.
+ **Häufige Replikationsprobleme wie Replikatverzögerung, diagnostizieren** – Replikatverzögerung ist die Zeit in Millisekunden, die der Seiten-Cache einer Reader-Instance hinter dem Cache der Writer-Instance zurückbleibt. Diese Verzögerung tritt auf, weil Aurora-Cluster eine asynchrone Replikation verwenden, wie unter [Replikation mit Amazon Aurora](Aurora.Replication.md)beschrieben. Diese ist in der Spalte `replica_lag_in_msec` in den von dieser Funktion zurückgegebenen Ergebnissen zu sehen. Verzögerungen können auch auftreten, wenn eine Abfrage aufgrund von Konflikten mit der Wiederherstellung auf einem Standby-Server abgebrochen wird. Unter `pg_stat_database_conflicts()` können Sie nachsehen, ob ein solcher Konflikt die Replikatverzögerung verursacht (oder nicht). Weitere Informationen finden Sie unter [Die Statistikerfassung](https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-DATABASE-CONFLICTS-VIEW) in der *PostgreSQL-Dokumentation*. Weitere Informationen zu Hochverfügbarkeit und Replikation finden Sie unter [Häufig gestellte Fragen zu Amazon Aurora](https://aws.amazon.com/rds/aurora/faqs/#High_Availability_and_Replication).
Amazon CloudWatch speichert `replica_lag_in_msec`-Ergebnisse im Laufe der Zeit als `AuroraReplicaLag`-Metrik. Weitere Informationen zur Verwendung der CloudWatch-Metriken für Aurora finden Sie unter [Überwachung von Amazon Aurora Aurora-Metriken mit Amazon CloudWatch](monitoring-cloudwatch.md).
Weitere Informationen zur Fehlerbehebung bei Aurora-Lesereplikaten und Neustarts finden Sie unter [Warum ist mein Amazon-Aurora-Lesereplikat in den Rückstand geraten und wurde neu gestartet?](https://aws.amazon.com/premiumsupport/knowledge-center/aurora-read-replica-restart/) im [AWS Support Center](https://console.aws.amazon.com/support/home#/).
## Beispiele
Im folgenden Beispiel wird veranschaulicht, wie Sie den Replikationsstatus aller Instances in einem Aurora-PostgreSQL-DB-Cluster abrufen:
```
=> SELECT *
FROM aurora_replica_status();
```
Das folgende Beispiel zeigt die Writer-Instance im Aurora-PostgreSQL-DB-Cluster `docs-lab-apg-main`:
```
=> 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
```
Im folgenden Beispiel werden alle Reader-Instances in einem Cluster aufgeführt:
```
=> 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)
```
Im folgenden Beispiel werden alle Instances aufgeführt und es wird angegeben, wie weit jede Instance hinter dem Writer zurückbleibt und wie lange seit dem letzten Update:
```
=> 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
Gibt eine Zeile pro Serverprozess zurück, in der Informationen zur aktuellen Aktivität dieses Prozesses angezeigt werden
## Syntax
```
aurora_stat_activity();
```
## Argumente
Keine
## Rückgabetyp
Gibt eine Zeile pro Serverprozess zurück. Zusätzlich zu den `pg_stat_activity`-Spalten wird das folgende Feld hinzugefügt:
+ planid – Plan-ID
## Nutzungshinweise
Eine zusätzliche Ansicht zu `pg_stat_activity` mit denselben Spalten sowie einer zusätzlichen `plan_id`-Spalte, die den aktuellen Abfrageausführungsplan darstellt
`aurora_compute_plan_id` muss aktiviert sein, damit die Ansicht eine plan\$1id zurückgibt.
Diese Funktion ist in den Aurora-PostgreSQL-Versionen 14.10, 15.5 und für alle späteren Versionen verfügbar.
## Beispiele
Die folgende Beispielabfrage aggregiert die Hauptlast nach query\$1id und 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)
```
Wenn sich der für query\$1id verwendete Plan ändert, wird von aurora\$1stat\$1activity eine neue plan\$1id gemeldet.
```
count | query_id | plan_id
-------+----------------------+-------------
10 | -5471422286312252535 | 1602979607
1 | -6907107586630739258 | -1809935983
1 | -2446282393000597155 | -207532066
(3 rows)
```
# aurora\$1stat\$1backend\$1waits
Zeigt Statistiken für die Warteaktivität für einen bestimmten Backend-Prozess an.
## Syntax
```
aurora_stat_backend_waits(pid)
```
## Argumente
`pid` – Die ID für den Backend-Prozess. Sie können Prozess-IDs in der Ansicht `pg_stat_activity` abrufen.
## Rückgabetyp
SETOF-Datensatz mit den folgenden Spalten:
+ `type_id` – Eine Zahl, die die Art des Warteereignisses angibt, wie `1` für eine einfache Sperre (`LWLock`), `3` für eine Sperre oder `6` für eine Clientsitzung, um nur einige Beispiele zu nennen. Diese Werte werden aussagekräftig, wenn Sie die Ergebnisse dieser Funktion mit Spalten der Funktion `aurora_stat_wait_type` verbinden, wie in [Beispiele](#aurora_stat_backend_waits-examples) gezeigt.
+ `event_id` – Eine ID-Nummer für das Warteereignis. Verbinden Sie diesen Wert mit den Spalten von `aurora_stat_wait_event`, um aussagekräftige Ereignisnamen zu erhalten.
+ `waits` – Die Anzahl der Warteereignisse, die für die angegebene Prozess-ID aufgelaufen sind.
+ `wait_time` – Wartezeit in Millisekunden.
## Nutzungshinweise
Sie können diese Funktion verwenden, um bestimmte Backend-Warteereignisse (Sitzung) zu analysieren, die seit dem Öffnen einer Verbindung aufgetreten sind. Aussagekräftigere Informationen über Warteereignisnamen und -typen erhalten Sie, wenn Sie diese Funktion mit `aurora_stat_wait_type` und `aurora_stat_wait_event` kombinieren, indem Sie JOIN verwenden, wie in den Beispielen gezeigt.
## Beispiele
Dieses Beispiel zeigt alle Warteereignisse, Typen und Ereignisnamen für die Backend-Prozess-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
```
Dieses Beispiel zeigt aktuelle und kumulative Wartetypen und -ereignisse für alle aktiven Sitzungen (`pg_stat_activity state <> 'idle'`) (aber ohne die aktuelle Sitzung, die die Funktion aufruft (`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
```
Dieses Beispiel zeigt aktuelle und die drei wichtigsten (3) kumulativen Wartetypen und Warteereignisse für alle aktiven Sitzungen (`pg_stat_activity state <> 'idle'`) ohne die aktuelle Sitzung (`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` ist eine Statistikanzeige mit Informationen über Cache-Schreibvorgänge für optimierte Lesevorgänge.
## Syntax
```
aurora_stat_bgwriter()
```
## Argumente
Keine
## Rückgabetyp
SETOF-Datensatz mit allen Spalten von `pg_stat_bgwriter` und den folgenden zusätzlichen Spalten. Weitere Informationen zu den Spalten von `pg_stat_bgwriter` finden Sie unter [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).
Sie können die Statistiken für diese Funktion mit `pg_stat_reset_shared("bgwriter")` zurücksetzen.
+ `orcache_blks_written` – Gesamtzahl der geschriebenen Cache-Datenblöcke für optimierte Lesevorgänge.
+ `orcache_blk_write_time` – Wenn `track_io_timing` aktiviert ist, wird die Gesamtzeit, die für das Schreiben von Cache-Datendateiblöcken für optimierte Lesevorgänge aufgewendet wurde, in Millisekunden aufgezeichnet. Weitere Informationen finden Sie unter [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
## Nutzungshinweise
Diese Funktion steht in folgenden Aurora-PostgreSQL-Versionen zur Verfügung:
+ 15.4 und höhere 15-Versionen
+ 14.9 und höhere 14-Versionen
## Beispiele
```
=> select * from aurora_stat_bgwriter();
-[ RECORD 1 ]-----------------+-----------
orcache_blks_written | 246522
orcache_blk_write_time | 339276.404
```
# aurora\$1stat\$1database
Enthält alle Spalten von pg\$1stat\$1database und fügt am Ende neue Spalten hinzu.
## Syntax
```
aurora_stat_database()
```
## Argumente
Keine
## Rückgabetyp
SETOF-Datensatz mit allen Spalten von `pg_stat_database` und den folgenden zusätzlichen Spalten. Weitere Informationen zu den Spalten von `pg_stat_database` finden Sie unter [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`: Gesamtzahl der gemeinsam genutzten Blöcke, die aus dem Aurora-Speicher in dieser Datenbank gelesen wurden.
+ `orcache_blks_hit`: Gesamtzahl der Treffer im Cache für optimierte Lesevorgänge in dieser Datenbank.
+ `local_blks_read`: Gesamtzahl der in dieser Datenbank gelesenen lokalen Blöcke.
+ `storage_blk_read_time`: Wenn `track_io_timing` aktiviert ist, wird die Gesamtzeit für das Lesen von Datendateiblöcken aus dem Aurora-Speicher in Millisekunden aufgezeichnet. Andernfalls beträgt der Wert Null. Weitere Informationen finden Sie unter [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
+ `local_blk_read_time`: Wenn `track_io_timing` aktiviert ist, wird die Gesamtzeit für das Lesen von lokalen Datendateiblöcken in Millisekunden aufgezeichnet. Andernfalls beträgt der Wert Null. Weitere Informationen finden Sie unter [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
+ `orcache_blk_read_time`: Wenn `track_io_timing` aktiviert ist, wird die Gesamtzeit für das Lesen von Datendateiblöcken aus dem Cache für optimierte Lesevorgänge in Millisekunden aufgezeichnet. Andernfalls beträgt der Wert Null. Weitere Informationen finden Sie unter [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
**Anmerkung**
Der Wert von `blks_read` ist die Summe von `storage_blks_read`, `orcache_blks_hit` und `local_blks_read`.
Der Wert von `blk_read_time` ist die Summe von `storage_blk_read_time`, `orcache_blk_read_time` und `local_blk_read_time`.
## Nutzungshinweise
Diese Funktion steht in folgenden Aurora-PostgreSQL-Versionen zur Verfügung:
+ 15.4 und höhere 15-Versionen
+ 14.9 und höhere 14-Versionen
## Beispiele
Das folgende Beispiel zeigt, wie alle Spalten von `pg_stat_database` enthalten sind und am Ende 6 neue Spalten angefügt werden:
```
=> 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
Meldet kumulative Aktivitäten für jeden Data-Manipulation-Language-Vorgangstyp (DML) in einer Datenbank in einem Aurora-PostgreSQL-Cluster.
## Syntax
```
aurora_stat_dml_activity(database_oid)
```
## Argumente
*database\$1oid*
Die Objekt-ID (OID) der Datenbank im Aurora-PostgreSQL-Cluster.
## Rückgabetyp
SETOF-Datensatz
## Nutzungshinweise
Die Funktion `aurora_stat_dml_activity` ist nur mit Version 3.1 von Aurora PostgreSQL verfügbar, die mit der PostgreSQL-Engine 11.6 und höher kompatibel ist.
Verwenden Sie diese Funktion in Aurora-PostgreSQL-Clustern mit einer großen Anzahl von Datenbanken, um zu ermitteln, welche Datenbanken mehr oder langsamere DML-Aktivitäten oder beides haben.
Die Funktion `aurora_stat_dml_activity` gibt die Anzahl der Ausführungen und die kumulative Latenz in Mikrosekunden für SELECT-, INSERT-, UPDATE- und DELETE-Operationen zurück. Der Bericht enthält nur erfolgreiche DML-Operationen.
Mit der PostgreSQL-Statistikzugriffsfunktion `pg_stat_reset` können Sie diese Statistik zurücksetzen. Mit der Funktion `pg_stat_get_db_stat_reset_time` können Sie überprüfen, wann diese Statistik zuletzt zurückgesetzt wurde. Weitere Informationen zu PostgreSQL-Statistikzugriffsfunktionen finden Sie unter [Die Statistikerfassung](https://www.postgresql.org/docs/9.1/monitoring-stats.html) in der PostgreSQL-Dokumentation.
## Beispiele
Im folgenden Beispiel wird gezeigt, wie Sie DML-Aktivitätsstatistiken für die verbundene Datenbank melden.
```
––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
```
Im folgenden Beispiel sehen Sie DML-Aktivitätsstatistiken für alle Datenbanken im Aurora-PostgreSQL-Cluster. Dieser Cluster hat zwei Datenbanken, `postgres` und `mydb`. Die durch Komma getrennte Liste entspricht den Feldern `select_count`, `select_latency_microsecs`, `insert_count`, `insert_latency_microsecs`, `update_count`, `update_latency_microsecs`, `delete_count` und `delete_latency_microsecs`.
Aurora PostgreSQL erstellt und verwendet eine Systemdatenbank namens `rdsadmin`, um administrative Vorgänge wie Backups, Wiederherstellungen, Zustandsprüfungen, Replikationen usw. zu unterstützen. Diese DML-Operationen haben keine Auswirkungen auf Ihren Aurora-PostgreSQL-Cluster.
```
=> 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)
```
Das folgende Beispiel zeigt DML-Aktivitätsstatistiken für alle Datenbanken, die aus Gründen der Lesbarkeit in Spalten angeordnet sind.
```
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
```
Das folgende Beispiel zeigt die durchschnittliche kumulative Latenz (kumulative Latenz geteilt durch die Anzahl) jeder DML-Operation für die Datenbank mit der OID `16401`.
```
=> 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
Ruft die kumulative Commit-Latenz in Mikrosekunden für Aurora-PostgreSQL-Datenbanken ab. Die *Commit-Latenz* wird als Zeit zwischen dem Senden einer Commit-Anforderung und dem Empfang der Commit-Bestätigung gemessen.
## Syntax
```
aurora_stat_get_db_commit_latency(database_oid)
```
## Argumente
*database\$1oid*
Die Objekt-ID (OID) der Aurora-PostgreSQL-Datenbank.
## Rückgabetyp
SETOF-Datensatz
## Nutzungshinweise
Amazon CloudWatch verwendet diese Funktion, um die durchschnittliche Commit-Latenz zu berechnen. Weitere Informationen zu Amazon-CloudWatch-Metriken und zur Behebung einer hohen Commit-Latenz finden Sie unter [Anzeigen von Metriken in der Amazon-RDS-Konsole](USER_Monitoring.md) und [Making better decisions about Amazon RDS with Amazon CloudWatch metrics](https://aws.amazon.com/blogs/database/making-better-decisions-about-amazon-rds-with-amazon-cloudwatch-metrics/).
Mit der PostgreSQL-Statistikzugriffsfunktion `pg_stat_reset` können Sie diese Statistik zurücksetzen. Mit der Funktion `pg_stat_get_db_stat_reset_time` können Sie überprüfen, wann diese Statistik zuletzt zurückgesetzt wurde. Weitere Informationen zu PostgreSQL-Statistikzugriffsfunktionen finden Sie unter [Die Statistikerfassung](https://www.postgresql.org/docs/9.1/monitoring-stats.html) in der PostgreSQL-Dokumentation.
## Beispiele
Im folgenden Beispiel wird die kumulative Commit-Latenz für jede Datenbank im Cluster `pg_database` abgerufen.
```
=> 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
```
Im folgenden Beispiel wird die kumulative Commit-Latenz für die aktuell verbundene Datenbank abgerufen. Vor dem Aufruf der Funktion `aurora_stat_get_db_commit_latency` wird im Beispiel zuerst `\gset` verwendet, um eine Variable für das Argument `oid` zu definieren und ihren Wert aus der verbundenen Datenbank zu beziehen.
```
––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
```
Im folgenden Beispiel wird die kumulative Commit-Latenz für die `mydb`-Datenbank im Cluster `pg_database` abgerufen. Dann wird diese Statistik mit der Funktion `pg_stat_reset` zurückgesetzt und die Ergebnisse werden angezeigt. Abschließend wird die Funktion `pg_stat_get_db_stat_reset_time` ausgeführt, um zu überprüfen, wann diese Statistik zuletzt zurückgesetzt wurde.
```
=> 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
Zeigt die Cache-Auslastung für das logische Write-Ahead-Protokoll (WAL) pro Slot an.
## Syntax
```
SELECT * FROM aurora_stat_logical_wal_cache()
```
## Argumente
Keine
## Rückgabetyp
SETOF-Datensatz mit den folgenden Spalten:
+ `name` – Der Name der Replikationsgruppe.
+ `active_pid` – Die ID des Walsender-Prozesses.
+ `cache_hit` – Die Gesamtzahl der WAL-Cache-Treffer seit dem letzten Reset.
+ `cache_miss` – Die Gesamtzahl der WAL-Cache-Fehler seit dem letzten Reset.
+ `blks_read` – Die Gesamtzahl der Wal-Cache-Leseanfragen.
+ `hit_rate` – Die WAL-Cache-Trefferrate (cache\$1hit/blks\$1read).
+ `last_reset_timestamp` – Das letzte Mal, dass der Zähler zurückgesetzt wurde.
## Nutzungshinweise
Diese Funktion steht in folgenden Aurora-PostgreSQL-Versionen zur Verfügung:
+ 15.2 und alle höheren Versionen
+ 14.7 und höhere Versionen
+ 13.8 und höhere Versionen
+ 12.12 und höhere Versionen
+ 11.17 und höhere Versionen
## Beispiele
Das folgende Beispiel zeigt zwei Replikations-Slots mit nur einer aktiven `aurora_stat_logical_wal_cache`-Funktion.
```
=> 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
Meldet die Speicherkontextnutzung für jeden PostgreSQL-Prozess.
## Syntax
```
aurora_stat_memctx_usage()
```
## Argumente
Keine
## Rückgabetyp
SETOF-Datensatz mit den folgenden Spalten:
+ `pid` – die ID des Prozesses.
+ `name` – der Name des Speicherkontexts.
+ `allocated` – Die Anzahl der Byte, die der Speicherkontext aus dem zugrunde liegenden Speichersubsystem abgerufen hat.
+ `used` – Die Anzahl der an Clients des Speicherkontextes übergebenen Byte.
+ `instances` – Die Anzahl der derzeit existierenden Kontexte dieses Typs.
## Nutzungshinweise
Diese Funktion zeigt die Speicherkontextnutzung für jeden PostgreSQL-Prozess an. Einige Prozesse sind mit `anonymous` beschriftet. Die Prozesse werden nicht offengelegt, da sie eingeschränkte Schlüsselwörter enthalten.
Diese Funktion steht ab den folgenden Aurora-PostgreSQL-Versionen zur Verfügung:
+ 15.3 und höhere 15-Versionen
+ 14.8 und höhere 14-Versionen
+ 13.11 und höhere 13-Versionen
+ 12.15 und höhere 12-Versionen
+ 11.20 und höhere 11-Versionen
## Beispiele
Im folgenden Beispiel sehen Sie die Ergebnisse vom Aufruf der Funktion `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)
```
Einige eingeschränkte Schlüsselwörter werden ausgeblendet und die Ausgabe sieht wie folgt aus:
```
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
Diese Funktion zeigt mehrstufige Cache-Statistiken an.
## Syntax
```
aurora_stat_optimized_reads_cache()
```
## Argumente
Keine
## Rückgabetyp
SETOF-Datensatz mit den folgenden Spalten:
+ `total_size` – Gesamtgröße des Cache für optimierte Lesevorgänge
+ `used_size` – Verwendete Seitengröße im Cache für optimierte Lesevorgänge
## Nutzungshinweise
Diese Funktion steht in folgenden Aurora-PostgreSQL-Versionen zur Verfügung:
+ 15.4 und höhere 15-Versionen
+ 14.9 und höhere 14-Versionen
## Beispiele
Das folgende Beispiel zeigt die Ausgabe für eine r6gd.8xlarge-Instance:
```
=> 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
Gibt eine Zeile für jeden nachverfolgten Ausführungsplan zurück
## Syntax
```
aurora_stat_plans(
showtext
)
```
## Argumente
+ showtext – Zeigt den Abfrage- und Plantext an. Gültige Werte sind NULL, true oder false. Bei true werden Abfrage- und Plantext angezeigt.
## Rückgabetyp
Gibt für jeden nachverfolgten Plan eine Zeile zurück, die alle Spalten von `aurora_stat_statements` und die folgenden zusätzlichen Spalten enthält
+ planid – Plan-ID
+ explain\$1plan – Erklärt den Plantext
+ plan\$1type:
+ `no plan` – Kein Plan wurde erfasst
+ `estimate` – Plan mit geschätzten Kosten erfasst
+ `actual` – Plan mit EXPLAIN ANALYZE erfasst
+ plan\$1captured\$1time – Zeit der letzten Planerfassung
## Nutzungshinweise
`aurora_compute_plan_id` muss aktiviert sein und `pg_stat_statements` muss sich in `shared_preload_libraries` befinden, damit die Pläne nachverfolgt werden können.
Die Anzahl der verfügbaren Pläne wird durch den im Parameter `pg_stat_statements.max` festgelegten Wert gesteuert. Wenn `aurora_compute_plan_id` aktiviert ist, können Sie die Pläne bis zu diesem angegebenen Wert in `aurora_stat_plans` nachverfolgen.
Diese Funktion ist in den Aurora-PostgreSQL-Versionen 14.10, 15.5 und für alle späteren Versionen verfügbar.
## Beispiele
Im folgenden Beispiel werden die beiden Pläne zur Abfrage-ID -5471422286312252535 erfasst und die Statistik der Anweisungen wird über die planid nachverfolgt.
```
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
Setzt den Zähler für den logischen WAL-Cache zurück.
## Syntax
So setzen Sie einen bestimmten Slot zurück
```
SELECT * FROM aurora_stat_reset_wal_cache('slot_name')
```
So setzen Sie alle Slots zurück
```
SELECT * FROM aurora_stat_reset_wal_cache(NULL)
```
## Argumente
`NULL` oder `slot_name`
## Rückgabetyp
Statusmeldung, Textzeichenfolge
+ Setzen Sie den logischen WAL-Cache-Zähler zurück – Erfolgsmeldung. Dieser Text wird zurückgegeben, wenn die Funktion erfolgreich ist.
+ Der Replikations-Slot wurde nicht gefunden. Bitte versuchen Sie es noch einmal. – Fehlernachricht Dieser Text wird zurückgegeben, wenn die Funktion nicht erfolgreich ist.
## Nutzungshinweise
Diese Funktion steht für die folgenden Versionen zur Verfügung.
+ Aurora PostgreSQL 14.5 und höher
+ Aurora PostgreSQL 13.8 und höhere Versionen
+ Aurora PostgreSQL 12.12 und höhere Versionen
+ Aurora PostgreSQL 11.17 und höhere Versionen
## Beispiele
Im folgenden Beispiel wird die `aurora_stat_reset_wal_cache`-Funktion verwendet, um einen Slot namens `test_results` zurückzusetzen. Anschließend wird versucht, einen Slot zurückzusetzen, der nicht existiert.
```
=> 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
Meldet die Ressourcennutzung in Echtzeit, bestehend aus Backend-Ressourcenmetriken und CPU-Auslastung für alle Backend-Prozesse von Aurora PostgreSQL
## Syntax
```
aurora_stat_resource_usage()
```
## Argumente
Keine
## Rückgabetyp
SETOF-Datensatz mit Spalten:
+ pid – Prozess-ID
+ allocated\$1memory – Vom Prozess zugewiesener Gesamtspeicher in Byte
+ used\$1memory – Tatsächlich vom Prozess genutzter Speicher in Byte
+ cpu\$1usage\$1percent – Prozentsatz der CPU-Auslastung des Prozesses
## Nutzungshinweise
Diese Funktion zeigt die Backend-Ressourcennutzung für jeden Backend-Prozess von Aurora PostgreSQL an.
Diese Funktion steht ab den folgenden Aurora-PostgreSQL-Versionen zur Verfügung:
+ Aurora PostgreSQL 17.5 und höhere Versionen von 17
+ Aurora PostgreSQL 16.9 und höhere Versionen von 16
+ Aurora PostgreSQL 15.13 und höhere Versionen von 15
+ Aurora PostgreSQL 14.18 und höhere Versionen von 14
+ Aurora PostgreSQL 13.21 und höhere Versionen von 13
## Beispiele
Im folgenden Beispiel wird die Ausgabe der Funktion `aurora_stat_resource_usage` gezeigt.
```
=> 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
Zeigt alle Spalten von `pg_stat_statements` an und fügt am Ende weitere Spalten hinzu.
## Syntax
```
aurora_stat_statements(showtext boolean)
```
## Argumente
*showtext boolean*
## Rückgabetyp
SETOF-Datensatz mit allen Spalten von `pg_stat_statements` und den folgenden zusätzlichen Spalten. Weitere Informationen zu den Spalten von `pg_stat_statements` finden Sie unter [https://www.postgresql.org/docs/current/pgstatstatements.html](https://www.postgresql.org/docs/current/pgstatstatements.html).
Sie können die Statistiken für diese Funktion mit `pg_stat_statements_reset()` zurücksetzen.
+ `storage_blks_read`: Gesamtzahl der gemeinsam genutzten Blöcke, die von dieser Anweisung aus dem Aurora-Speicher gelesen wurden.
+ `orcache_blks_hit`: Gesamtzahl der mit dieser Anweisung erzielten Treffer im Cache für optimierte Lesevorgänge.
+ `storage_blk_read_time` – Wenn `track_io_timing` aktiviert ist, wird die Gesamtzeit in Millisekunden aufgezeichnet, die die Anweisung für das Lesen von gemeinsam genutzten Blöcken aus dem Aurora-Speicher benötigt hat. Andernfalls beträgt der Wert Null. Weitere Informationen finden Sie unter [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
+ `local_blk_read_time` – Wenn `track_io_timing` aktiviert ist, wird die Gesamtzeit in Millisekunden aufgezeichnet, die die Anweisung für das Lesen von lokalen Blöcken benötigt hat. Andernfalls beträgt der Wert Null. Weitere Informationen finden Sie unter [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
+ `orcache_blk_read_time` – Wenn `track_io_timing` aktiviert ist, wird die Gesamtzeit in Millisekunden aufgezeichnet, die die Anweisung für das Lesen von gemeinsam genutzten Blöcken aus dem Cache für optimierte Lesevorgänge benötigt hat. Andernfalls beträgt der Wert Null. Weitere Informationen finden Sie unter [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
+ `total_plan_peakmem` – Gesamtsumme der Werte zur maximalen Speichernutzung während der Planungsphase für alle Aufrufe dieser Anweisung. Um die durchschnittliche maximale Speichernutzung während der Planung für die Anweisung zu ermitteln, teilen Sie diesen Wert durch die Anzahl der Aufrufe.
+ `min_plan_peakmem` – Kleinster Wert der maximalen Speichernutzung während der Planung über alle Aufrufe dieser Anweisung hinweg
+ `max_plan_peakmem` – Größter Wert der maximalen Speichernutzung während der Planung über alle Aufrufe dieser Anweisung hinweg
+ `total_exec_peakmem` – Gesamtsumme der Werte zur maximalen Speichernutzung während der Ausführungsphase für alle Aufrufe dieser Anweisung. Um die durchschnittliche maximale Speichernutzung während der Ausführung für die Anweisung zu ermitteln, teilen Sie diesen Wert durch die Anzahl der Aufrufe.
+ `min_exec_peakmem` – Kleinster Wert der maximalen Speichernutzung in Byte während der Ausführung über alle Aufrufe dieser Anweisung hinweg
+ `max_exec_peakmem` – Größter Wert der maximalen Speichernutzung in Byte während der Ausführung über alle Aufrufe dieser Anweisung hinweg
**Anmerkung**
`total_plan_peakmen`, `min_plan_peakmem` und `max_plan_peakmem` werden nur überwacht, wenn die Einstellung `pg_stat_statements.track_planning` aktiviert ist.
## Nutzungshinweise
Zur Verwendung der Funktion aurora\$1stat\$1statements() müssen Sie die Erweiterung `pg_stat_statements` in den Parameter `shared_preload_libraries` aufnehmen.
Diese Funktion steht in folgenden Aurora-PostgreSQL-Versionen zur Verfügung:
+ 15.4 und höhere 15-Versionen
+ 14.9 und höhere 14-Versionen
Die Spalten zur maximalen Speichernutzung sind in den folgenden Versionen verfügbar:
+ 16.3 und höhere Versionen
+ 15.7 und höhere Versionen
+ 14.12 und höhere Versionen
## Beispiele
Das folgende Beispiel zeigt, wie alle Spalten von pg\$1stat\$1statements enthalten sind und am Ende 11 neue Spalten angefügt werden:
```
=> 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
Meldet Warteereignisinformationen für die Aurora-PostgreSQL-DB-Instance.
## Syntax
```
aurora_stat_system_waits()
```
## Argumente
Keine
## Rückgabetyp
SETOF-Datensatz
## Nutzungshinweise
Diese Funktion gibt die kumulative Anzahl der Wartezeiten und die kumulative Wartezeit für jedes Warteereignis zurück, das von der DB-Instance generiert wird, mit der Sie derzeit verbunden sind.
Der zurückgegebene Datensatz enthält die folgenden Felder:
+ `type_id` – die ID des Warteereignistyps.
+ `event_id` – die ID des Warteereignisses.
+ `waits` – die Häufigkeit, mit der das Warteereignis aufgetreten ist.
+ `wait_time` – die Gesamtzeit in Mikrosekunden, die auf dieses Ereignis gewartet wurde.
Die von dieser Funktion zurückgegebenen Statistiken werden zurückgesetzt, wenn eine DB-Instance neu gestartet wird.
## Beispiele
Im folgenden Beispiel sehen Sie Ergebnisse vom Aufruf der Funktion `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
```
Im folgenden Beispiel wird gezeigt, wie Sie diese Funktion mit `aurora_stat_wait_event` und `aurora_stat_wait_type` ausführen können, um besser lesbare Ergebnisse zu erzeugen.
```
=> 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
Listet alle unterstützten Warteereignisse für Aurora PostgreSQL auf. Informationen zu Aurora PostgreSQL-Warteereignissen finden Sie unter [Amazon-Aurora-PostgreSQL-Warteereignisse](AuroraPostgreSQL.Reference.Waitevents.md).
## Syntax
```
aurora_stat_wait_event()
```
## Argumente
Keine
## Rückgabetyp
SETOF-Datensatz mit den folgenden Spalten:
+ type\$1id – die ID des Warteereignistyps.
+ event\$1id – die ID des Warteereignisses.
+ type\$1name – Name des Wartetyps
+ event\$1name – Name des Warteereignisses
## Nutzungshinweise
Kombinieren Sie diese Funktion mit anderen Funktionen wie `aurora_stat_wait_type` und `aurora_stat_system_waits`, um Ereignisnamen mit Ereignistypen anstelle von IDs anzuzeigen. Namen von Warteereignissen, die von dieser Funktion zurückgegeben werden, sind die gleichen Namen, die von der Funktion `aurora_wait_report` zurückgegeben werden.
## Beispiele
Im folgenden Beispiel sehen Sie Ergebnisse vom Aufruf der Funktion `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
```
Im folgenden Beispiel werden `aurora_stat_wait_type` und `aurora_stat_wait_event` zusammengeführt, um aus Gründen der Lesbarkeit Typnamen und Ereignisnamen zurückzugeben.
```
=> 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
Listet alle unterstützten Wartetypen für Aurora PostgreSQL auf.
## Syntax
```
aurora_stat_wait_type()
```
## Argumente
Keine
## Rückgabetyp
SETOF-Datensatz mit den folgenden Spalten:
+ type\$1id – die ID des Warteereignistyps.
+ type\$1name – name des Wartetyps.
## Nutzungshinweise
Kombinieren Sie diese Funktion mit anderen Funktionen wie `aurora_stat_wait_event` und `aurora_stat_system_waits`, um Warteereignisnamen mit Warteereignistypen anstelle von IDs anzuzeigen. Namen von Wartetypen, die von dieser Funktion zurückgegeben werden, sind die gleichen Namen, die von der Funktion `aurora_wait_report` zurückgegeben werden.
## Beispiele
Im folgenden Beispiel sehen Sie Ergebnisse vom Aufruf der Funktion `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
Gibt den Zeichenfolgewert der Versionsnummer der PostgreSQL-kompatiblen Edition von Amazon Aurora zurück.
## Syntax
```
aurora_version()
```
## Argumente
Keine
## Rückgabetyp
CHAR- oder VARCHAR-Zeichenfolge
## Nutzungshinweise
Diese Funktion zeigt die Version der Datenbank-Engine der PostgreSQL-kompatiblen Edition von Amazon Aurora an. Die Versionsnummer wird als Zeichenfolge zurückgegeben im Format *major*.*minor*.*patch*. Weitere Informationen zu den Aurora-PostgreSQL-Versionsnummern erhalten Sie unter [Aurora-Versionsnummer](AuroraPostgreSQL.Updates.md#AuroraPostgreSQL.Updates.Versions.AuroraNumber).
Sie können auswählen, wann Upgrades von Nebenversionen angewendet werden sollen, indem Sie das Wartungsfenster für Ihren Aurora-PostgreSQL-DB-Cluster festlegen. Um zu erfahren wie, siehe [Warten eines Amazon Aurora-DB-Clusters](USER_UpgradeDBInstance.Maintenance.md).
Ab der Veröffentlichung der PostgreSQL-Versionen 13.3, 12.8, 11.13 und 10.18 und für alle späteren Versionen sind die Aurora-Versionsnummern genauer auf die PostgreSQL-Versionsnummern abgestimmt. Weitere Informationen zu allen Aurora-PostgreSQL-Versionen finden Sie unter [Updates für Amazon Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Updates.html) in den *Versionshinweisen für Aurora PostgreSQL*.
## Beispiele
Das folgende Beispiel zeigt die Ergebnisse des Aufrufs der `aurora_version`-Funktion auf einem Aurora-PostgreSQL-DB-Cluster, der [PostgreSQL 12.7, Aurora-PostgreSQL- Version 4.2](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Updates.html#AuroraPostgreSQL.Updates.20180305.42) ausführt und dann die gleiche Funktion auf einem Cluster mit [Aurora-PostgreSQL-Version 13.3](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Updates.html#AuroraPostgreSQL.Updates.20180305.133X) ausführt.
```
=> SELECT * FROM aurora_version();
aurora_version
----------------
4.2.2
SELECT * FROM aurora_version();
aurora_version
----------------
13.3.0
```
Dieses Beispiel zeigt, wie Sie die Funktion mit verschiedenen Optionen verwenden, um mehr über die Aurora-PostgreSQL-Version zu erfahren. Dieses Beispiel verwendet eine Aurora-Versionsnummer, die sich von der PostgreSQL-Versionsnummer unterscheidet.
```
=> 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)
```
In diesem nächsten Beispiel wird die Funktion mit den gleichen Optionen wie im vorherigen Beispiel verwendet. Dieses Beispiel hat keine Aurora-Versionsnummer, die sich von der PostgreSQL-Versionsnummer unterscheidet.
```
=> 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
Gibt die Log-Sequenznummer (LSN) zurück, die zur Identifizierung des Anfangs eines Datensatzes im Logical Write-Ahead Log (WAL)-Stream des Aurora-Cluster-Volumes verwendet wird.
## Syntax
```
aurora_volume_logical_start_lsn()
```
## Argumente
Keine
## Rückgabetyp
`pg_lsn`
## Nutzungshinweise
Diese Funktion identifiziert den Anfang des Datensatzes im logischen WAL-Stream für ein bestimmtes Aurora-Cluster-Volume. Sie können diese Funktion verwenden, während Sie ein Hauptversions-Upgrade durchführen, indem Sie logische Replikation und schnelles Klonen von Aurora verwenden, um zu ermitteln, an welcher LSN ein Snapshot oder ein Datenbankklon erstellt wird. Anschließend können Sie die logische Replikation verwenden, um die neueren Daten, die nach dem LSN aufgezeichnet wurden, kontinuierlich zu streamen und die Änderungen vom Publisher zum Subscriber zu synchronisieren.
Weitere Informationen zur Verwendung der logischen Replikation für ein Hauptversions-Upgrade finden Sie unter [Verwenden der logischen Replikation, um ein Hauptversions-Upgrade für Aurora PostgreSQL durchzuführen](AuroraPostgreSQL.MajorVersionUpgrade.md).
Diese Funktion steht für die folgenden Versionen von Aurora PostgreSQL zur Verfügung:
+ 15.2 und höhere 15-Versionen
+ 14.3 und höhere 14-Versionen
+ 13.6 und höhere 13-Versionen
+ 12.10 und höhere 12-Versionen
+ 11.15 und höhere 11-Versionen
+ 10.20 und höhere 10-Versionen
## Beispiele
Sie können die Log-Sequenznummer (LSN) mithilfe der folgenden Abfrage abrufen:
```
postgres=> SELECT aurora_volume_logical_start_lsn();
aurora_volume_logical_start_lsn
---------------
0/402E2F0
(1 row)
```
# aurora\$1wait\$1report
Diese Funktion zeigt die Aktivität „Warteereignis“ über einen bestimmten Zeitraum an.
## Syntax
```
aurora_wait_report([time])
```
## Argumente
*Zeit (optional) *
Die Zeit in Sekunden. Der Standardwert beträgt 10 Sekunden.
## Rückgabetyp
SETOF-Datensatz mit den folgenden Spalten:
+ type\$1name – Name des Wartetyps
+ event\$1name – Name des Warteereignisses
+ wait – Anzahl der Warteereignisse
+ wait\$1time – Wartezeit in Millisekunden
+ ms\$1per\$1wait – durchschnittliche Millisekunden pro Anzahl eines Warteereignisses
+ waits\$1per\$1xact – durchschnittliche Warteereignisse pro Anzahl einer Transaktion
+ ms\$1per\$1xact – durchschnittliche Millisekunden nach Anzahl der Transaktionen
## Nutzungshinweise
Diese Funktion ist ab Aurora-PostgreSQL-Release 1.1 verfügbar, die mit PostgreSQL 9.6.6 und höheren Versionen kompatibel ist.
Wenn Sie diese Funktion nutzen möchten, müssen Sie zuerst die Aurora-PostgreSQL-Erweiterung `aurora_stat_utils` wie folgt erstellen:
```
=> CREATE extension aurora_stat_utils;
CREATE EXTENSION
```
Weitere Informationen zu verfügbaren Aurora-PostgreSQL-Erweiterungsversionen finden Sie unter [Erweiterungsversionen für Amazon Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Extensions.html) in den *Versionshinweisen für Aurora PostgreSQL*.
Diese Funktion berechnet die Warteereignisse auf Instance-Ebene, indem zwei Snapshots von Statistikdaten aus der Funktion aurora\$1stat\$1system\$1waits() und den Postgre-SQL-Statistikansichten pg\$1stat\$1database verglichen werden.
Weitere Informationen über `aurora_stat_system_waits()` und `pg_stat_database` finden Sie unter [Die Statistikerfassung](https://www.postgresql.org/docs/current/monitoring-stats.html#PG-STAT-DATABASE-VIEW) in der *PostgreSQL-Dokumentation*.
Wenn diese Funktion ausgeführt wird, erstellt sie einen ersten Snapshot, wartet die angegebene Anzahl von Sekunden und erstellt dann einen zweiten Snapshot. Die Funktion vergleicht die beiden Snapshots und gibt den Unterschied zurück. Dieser Unterschied stellt die Aktivität der Instance für dieses Zeitintervall dar.
In der Writer-Instance zeigt die Funktion auch die Anzahl der Transaktionen, für die ein Commit ausgeführt wurde, und TPS (Transaktionen pro Sekunde) an. Diese Funktion gibt Informationen auf Instance-Ebene zurück und enthält alle Datenbanken in der Instance.
## Beispiele
Dieses Beispiel zeigt, wie die Erweiterung aurora\$1stat\$1utils erstellt wird, um die Funktion aurora\$1wait\$1report verwenden zu können.
```
=> CREATE extension aurora_stat_utils;
CREATE EXTENSION
```
Dieses Beispiel zeigt, wie der Wartebericht 10 Sekunden lang überprüft wird.
```
=> 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
```
Dieses Beispiel zeigt, wie der Wartebericht 60 Sekunden lang überprüft wird.
```
=> 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-Parameter
Sie können Ihr Amazon-Aurora-DB-Cluster auf dieselbe Art und Weise verwalten, wie Sie Ihre anderen Amazon-RDS-DB-Instances verwalten, und zwar indem Sie die Parameter in einer DB-Parametergruppe verwenden. Amazon Aurora unterscheidet sich jedoch von Amazon RDS dadurch, dass ein Aurora-DB-Cluster mehrere DB-Instances hat. Einige der Parameter, mit denen Sie Ihren Amazon-Aurora-DB-Cluster verwalten, werden auf den gesamten Cluster angewendet, andere hingegen werden wie folgt nur auf eine bestimmte DB-Instance im DB-Cluster angewendet:
+ **DB-Cluster-Parametergruppe** – Eine DB-Cluster-Parametergruppe enthält den Satz von Engine-Konfigurationsparametern, die für den gesamten Aurora-DB-Cluster gelten. Beispielsweise ist die Cluster-Cache-Verwaltung ein Feature eines Aurora-DB-Clusters, der von dem Parameter `apg_ccm_enabled` kontrolliert wird, der Teil der DB-Cluster-Parametergruppe ist. Die DB-Cluster-Parametergruppe enthält auch Standardeinstellungen für die DB-Parametergruppe für die DB-Instances, aus denen der Cluster besteht.
+ **DB-Parametergruppe** – Eine DB-Parametergruppe ist der Satz von Engine-Konfigurationswerten, die für eine bestimmte DB-Instance dieses Engine-Typs gelten. Die DB-Parametergruppen für die PostgreSQL-DB-Engine werden von einer RDS-for-PostgreSQL-DB-Instance und einem Aurora-PostgreSQL-DB-Cluster verwendet. Diese Konfigurationseinstellungen gelten für Eigenschaften, die je nach DB-Instances in einem Aurora-Cluster unterschiedlich sein können, z. B. Größe der Speicherpuffer.
Sie verwalten Parameter auf Cluster-Ebene in DB-Clusterparametergruppen. Sie verwalten Parameter auf Instance-Ebene in DB-Parametergruppen. Sie können Parameter mit der Amazon RDS-Konsole AWS CLI, der oder der Amazon RDS-API verwalten. Es gibt separate Befehle für das Verwalten von Parametern auf der Cluster- und Instance-Ebene.
+ [Verwenden Sie den Befehl -group, um Parameter auf Clusterebene in einer DB-Cluster-Parametergruppe zu verwalten. modify-db-cluster-parameter](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster-parameter-group.html) AWS CLI
+ Verwenden Sie den Befehl, um Parameter auf Instanzebene in einer DB-Parametergruppe für eine DB-Instance in einem DB-Cluster zu verwalten. [modify-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-parameter-group.html) AWS CLI
Weitere Informationen zu finden Sie AWS CLI unter [Verwenden von AWS CLI im AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-using.html) *Benutzerhandbuch*.
Weitere Informationen zu Parametergruppen finden Sie unter [Parametergruppen für Amazon Aurora](USER_WorkingWithParamGroups.md).
## Anzeigen von Aurora-PostgreSQL-DB-Cluster- und DB-Parametern
Sie können alle verfügbaren Standardparametergruppen für RDS-for-PostgreSQL-DB-Instances und für Aurora-PostgreSQL-DB-Cluster in der AWS-Managementkonsole anzeigen. Die Standardparametergruppen für alle DB-Engines und DB-Clustertypen und -versionen sind für jede AWS Region aufgeführt. Alle benutzerdefinierten Parametergruppen werden ebenfalls aufgeführt.
Anstatt sie in der anzusehen AWS-Managementkonsole, können Sie auch Parameter auflisten, die in DB-Cluster-Parametergruppen und DB-Parametergruppen enthalten sind, indem Sie die AWS CLI oder die Amazon RDS-API verwenden. Um beispielsweise Parameter in einer DB-Cluster-Parametergruppe aufzulisten, verwenden Sie den [describe-db-cluster-parameters](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-cluster-parameters.html) AWS CLI Befehl wie folgt:
```
aws rds describe-db-cluster-parameters --db-cluster-parameter-group-name default.aurora-postgresql12
```
Der Befehl gibt detaillierte JSON-Beschreibungen für jeden Parameter zurück. Sie können die Menge der zurückgegebenen Informationen reduzieren, indem Sie die Option `--query` verwenden. Beispielsweise können Sie den Parameternamen, seine Beschreibung und die zulässigen Werte für die standardmäßige Aurora-PostgreSQL-12-DB-Cluster-Parametergruppe wie folgt abrufen:
Für Linux, macOS oder 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}]'
```
Für 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}]"
```
Eine Aurora-DB-Cluster-Parametergruppe umfasst die DB-Instance-Parametergruppe und Standardwerte für eine bestimmte Aurora-DB-Engine. Sie können die Liste der DB-Parameter aus derselben Standardparametergruppe von Aurora PostgreSQL abrufen, indem Sie den folgenden [describe-db-parameters](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-parameters.html) AWS CLI Befehl verwenden.
Für Linux, macOS oder Unix:
```
aws rds describe-db-parameters --db-parameter-group-name default.aurora-postgresql12 \
--query 'Parameters[].[{ParameterName:ParameterName,Description:Description,ApplyType:ApplyType,AllowedValues:AllowedValues}]'
```
Für Windows:
```
aws rds describe-db-parameters --db-parameter-group-name default.aurora-postgresql12 ^
--query "Parameters[].[{ParameterName:ParameterName,Description:Description,ApplyType:ApplyType,AllowedValues:AllowedValues}]"
```
Die vorherigen Befehle geben Listen von Parametern aus dem DB-Cluster oder der DB-Parametergruppe mit Beschreibungen und anderen Details zurück, die in der Abfrage angegeben sind. Nachfolgend finden Sie eine Beispielantwort.
```
[
[
{
"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"
}
],...
```
Im Folgenden finden Sie Tabellen, die Werte für den standardmäßigen DB-Cluster-Parameter und den DB-Parameter für Aurora-PostgreSQL-Version 14 enthalten.
## Aurora-PostgreSQL-Parameter auf Cluster-Ebene
Sie können die für eine bestimmte Aurora PostgreSQL-Version verfügbaren Parameter auf Clusterebene mithilfe der AWS Management-Konsole, der AWS CLI oder der Amazon RDS-API anzeigen. Weitere Informationen zum Anzeigen von Parametern in einer Parametergruppe des DB-Clusters von Aurora PostgreSQL finden Sie unter [Parameterwerte für eine DB-Cluster-Parametergruppe in Amazon Aurora anzeigen](USER_WorkingWithParamGroups.ViewingCluster.md).
Einige Parameter auf Cluster-Ebene sind nicht in allen Versionen verfügbar und manche sind veraltet. Hinweise zum Anzeigen der Parameter einer bestimmten Aurora-PostgreSQL-Version finden Sie unter [Anzeigen von Aurora-PostgreSQL-DB-Cluster- und DB-Parametern](#AuroraPostgreSQL.Reference.ParameterGroups-viewing-parameters).
Die folgende Tabelle enthält beispielsweise die Parameter, die in der standardmäßigen DB-Cluster-Parametergruppe für Aurora PostgreSQL Version 14 verfügbar sind. Wenn Sie einen Aurora-PostgreSQL-DB-Cluster erstellen, ohne Ihre eigene benutzerdefinierte DB-Parametergruppe anzugeben, wird Ihr DB-Cluster mit der standardmäßigen Aurora-DB-Cluster-Parametergruppe für die gewählte Version erstellt, z. B. `default.aurora-postgresql14`, `default.aurora-postgresql13` usw.
Eine Auflistung der DB-Instance-Parameter für dieselbe Standard-DB-Cluster-Parametergruppe finden Sie unter [Aurora-PostgreSQL-Parameter auf Instance-Ebene](#AuroraPostgreSQL.Reference.Parameters.Instance).
| Parametername | Description | Standard |
| --- | --- | --- |
| ansi\$1constraint\$1trigger\$1ordering | Ändern Sie die Ausführungsreihenfolge von Einschränkungsauslösern für Kompatibilität mit dem ANSI-SQL-Standard. | – |
| ansi\$1force\$1foreign\$1key\$1checks | Stellen Sie sicher, dass referenzielle Aktionen wie kaskadiertes Löschen oder kaskadiertes Aktualisieren immer ablaufen, unabhängig von den diversen Auslöserkontexten der Aktion. | – |
| ansi\$1qualified\$1update\$1set\$1target | Unterstützt Tabellen- und Schemaqualifizierer in UPDATE … SET-Anweisungen. | – |
| apg\$1ccm\$1enabled | Aktivieren oder deaktivieren Sie die Cluster-Cache-Verwaltung für den Cluster. | – |
| apg\$1enable\$1batch\$1mode\$1function\$1execution | Aktiviert Batch-Modus-Funktionen, um mehrere Zeilen gleichzeitig zu verarbeiten. | – |
| apg\$1enable\$1correlated\$1any\$1transform | Ermöglicht es dem Planer, korrelierte ANY-Sublinks (IN/NOT IN Unterabfrage) nach Möglichkeit in JOIN umzuwandeln. | – |
| apg\$1enable\$1function\$1migration | Ermöglicht dem Planer, berechtigte Skalarfunktionen in die FROM-Klausel zu migrieren. | – |
| apg\$1enable\$1not\$1in\$1transform | Ermöglicht es dem Planer, NOT IN-Unterabfragen nach Möglichkeit in ANTI JOIN umzuwandeln. | – |
| apg\$1enable\$1remove\$1redundant\$1inner\$1joins | Ermöglicht dem Planer, redundante Inner Joins zu entfernen. | – |
| apg\$1enable\$1semijoin\$1push\$1down | Ermöglicht die Verwendung von Semijoin-Filtern für Hash-Joins. | – |
| apg\$1plan\$1mgmt.capture\$1plan\$1baselines | Baseline-Modus für Planerfassung. Manuell – Planerfassung für jede SQL-Anweisung aktivieren. Aus – Planerfassung deaktivieren. Automatisch – Planerfassung für Anweisungen in pg\$1stat\$1statement aktivieren, die die Berechtigungskriterien erfüllen. | aus |
| apg\$1plan\$1mgmt.max\$1databases | Legt die maximale Anzahl von Datenbanken fest, die Abfragen mit apg\$1plan\$1mgmt verwalten können. | 10 |
| apg\$1plan\$1mgmt.max\$1plans | Legt die maximale Anzahl von Plänen fest, die von apg\$1plan\$1mgmt zwischengespeichert werden können. | 10000 |
| apg\$1plan\$1mgmt.plan\$1retention\$1period | Maximale Anzahl von Tagen, seit ein Plan zuletzt verwendet wurde, bevor ein Plan automatisch gelöscht wird. | 32 |
| apg\$1plan\$1mgmt.unapproved\$1plan\$1execution\$1threshold | Geschätzte Gesamtplankosten, unter denen ein nicht genehmigter Plan ausgeführt wird. | 0 |
| apg\$1plan\$1mgmt.use\$1plan\$1baselines | Verwenden Sie nur genehmigte oder feste Pläne für verwaltete Anweisungen. | false |
| application\$1name | Legt den Namen der Anwendung fest, der in Statistiken und Protokollen verwendet werden soll. | – |
| array\$1nulls | Ermöglicht die Eingabe von NULL-Elementen in Arrays. | – |
| aurora\$1compute\$1plan\$1id | Überwacht Ausführungspläne von Abfragen, um die Ausführungspläne zu ermitteln, die zur aktuellen Datenbanklast beitragen, und um Leistungsstatistiken der Ausführungspläne im Laufe der Zeit zu verfolgen Weitere Informationen finden Sie unter [Überwachen von Abfrageausführungsplänen für Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraPostgreSQL.Monitoring.Query.Plans.html). | on |
| authentication\$1timeout | (s) Legt die Zeit fest, die maximal zulässig ist, um die Client-Authentifizierung durchzuführen. | – |
| auto\$1explain.log\$1analyze | Verwenden Sie EXPLAIN ANALYZE zur Planprotokollierung. | – |
| auto\$1explain.log\$1buffers | Protokollieren der Puffernutzung. | – |
| auto\$1explain.log\$1format | EXPLAIN-Format, das für die Planprotokollierung verwendet werden soll. | – |
| auto\$1explain.log\$1min\$1duration | Legt die Mindestausführungszeit fest, ab der Pläne protokolliert werden. | – |
| auto\$1explain.log\$1nested\$1statements | Protokollieren verschachtelter Anweisungen. | – |
| auto\$1explain.log\$1timing | Erfasst Timing-Daten, nicht nur Zeilenzahlen. | – |
| auto\$1explain.log\$1triggers | Fügt Auslöserstatistiken in Pläne ein. | – |
| auto\$1explain.log\$1verbose | Verwenden Sie EXPLAIN VERBOSE zur Planprotokollierung. | – |
| auto\$1explain.sample\$1rate | Bruchteil der zu verarbeitenden Abfragen. | – |
| autovacuum | Startet den Untervorgang der Selbstbereinigung. | – |
| autovacuum\$1analyze\$1scale\$1factor | Anzahl von Tupel-Einfügungen, -Aktualisierungen oder -Löschungen vor der Analyse als Bruchteil von Reltupeln. | 0,05 |
| autovacuum\$1analyze\$1threshold | Mindestanzahl von Tupel-Einfügungen, -Aktualisierungen oder -Löschungen vor der Analyse. | – |
| autovacuum\$1freeze\$1max\$1age | Alter, bei dem eine Selbstbereinigung für eine Tabelle ausgeführt werden soll, um einen Transaktions-ID-Wraparound zu verhindern. | – |
| autovacuum\$1max\$1workers | Legt die maximale Anzahl gleichzeitig ausgeführter Worker-Vorgänge für die Selbstbereinigung fest. | AM BESTEN (DBInstanceClassMemory/64371566592 ,3) |
| autovacuum\$1multixact\$1freeze\$1max\$1age | Multixact-Alter, bei dem eine Tabelle sich selbst bereinigt, um Multixact-Wraparound zu verhindern. | – |
| autovacuum\$1naptime | (s) Inaktivitätszeit zwischen Selbstbereinigungen. | 5 |
| autovacuum\$1vacuum\$1cost\$1delay | (ms) Bereinigungskostenverzögerung in Millisekunden für die Selbstbereinigung. | 5 |
| autovacuum\$1vacuum\$1cost\$1limit | Bereinigungskostenbetrag für die Selbstbereinigung, der vor der Inaktivität verfügbar ist. | AM BESTEN (log (/21474836480) \$1600.200) DBInstance ClassMemory |
| autovacuum\$1vacuum\$1insert\$1scale\$1factor | Anzahl von Tupel-Einfügungen vor der Bereinigung als Bruchteil von Reltupeln. | – |
| autovacuum\$1vacuum\$1insert\$1threshold | Mindestanzahl von Tupel-Einfügungen vor der Bereinigung oder -1 zum Deaktivieren von Bereinigungen. | – |
| autovacuum\$1vacuum\$1scale\$1factor | Anzahl von Tupel-Aktualisierungen oder -Löschungen vor der Bereinigung als Bruchteil von Reltupeln. | 0.1 |
| autovacuum\$1vacuum\$1threshold | Mindestanzahl von Tupel-Aktualisierungen oder -Löschungen vor der Bereinigung. | – |
| autovacuum\$1work\$1mem | (kB) Legt den maximalen Arbeitsspeicher fest, der von jedem Selbstbereinigungs-Worker-Prozess verwendet werden soll. | AM DBInstance ClassMemory GRÖSSTEN (/32768 ,131072) |
| babelfishpg\$1tds.default\$1server\$1name | Der Standardname des Babelfish-Servers | Microsoft SQL Server |
| babelfishpg\$1tds.listen\$1adressen | Legt den Host-Namen oder die IP-Adresse(n) fest, die auf TDS überwacht werden sollen. | \$1 |
| babelfishpg\$1tds.port | Legt den TDS-TCP-Port fest, den der Server überwacht. | 1433 |
| babelfishpg\$1tds.tds\$1debug\$1log\$1level | Legt die Protokollierungsstufe in TDS fest, 0 deaktiviert die Protokollierung | 1 |
| babelfishpg\$1tds.tds\$1default\$1numeric\$1precision | Legt die Standardgenauigkeit des numerischen Typs fest, der in den Metadaten der TDS-Spalte gesendet werden soll, wenn die Engine keine angibt. | 38 |
| babelfishpg\$1tds.tds\$1default\$1numeric\$1scale | Legt den Standardmaßstab des numerischen Typs fest, der in den Metadaten der TDS-Spalte gesendet werden soll, wenn die Engine keine angibt. | 8 |
| babelfishpg\$1tds.tds\$1default\$1packet\$1size | Legt die Standardpaketgröße für alle SQL.Server-Clients fest, die verbunden werden | 4096 |
| babelfishpg\$1tds.tds\$1default\$1protocol\$1version | Legt eine Standardversion des TDS-Protokolls für alle Clients fest, die verbunden werden | DEFAULT |
| babelfishpg\$1tds.tds\$1ssl\$1encrypt | Legt die SSL-Verschlüsselungsoption fest | 0 |
| babelfishpg\$1tds.tds\$1ssl\$1max\$1protocol\$1version | Legt die maximale SSL/TLS Protokollversion fest, die für die TDS-Sitzung verwendet werden soll. | TLSv12. |
| babelfishpg\$1tds.tds\$1ssl\$1min\$1protocol\$1version | Legt die SSL/TLS Mindestprotokollversion fest, die für die TDS-Sitzung verwendet werden soll. | TLSv1.2 von Aurora PostgreSQL Version 16, TLSv1 für Versionen älter als Aurora PostgreSQL Version 16 |
| babelfishpg\$1tsql.default\$1locale | Standardgebietsschema, das für Sortierungen verwendet wird, die von CREATE COLLATION erstellt wurden. | en-US |
| babelfishpg\$1tsql.migration\$1mode | Legt fest, ob mehrere Benutzerdatenbanken unterstützt werden | multi-db ab Aurora-PostgreSQL-Version 16, single-db für Versionen älter als Aurora-PostgreSQL-Version 16 |
| babelfishpg\$1tsql.server\$1colation\$1name | Name der Standardsortierung für den Server | sql\$1latin1\$1general\$1cp1\$1ci\$1as |
| babelfishpg\$1tsql.version | Legt die Ausgabe der Variablen @@VERSION fest | default |
| backend\$1flush\$1after | (8 Kb) Anzahl der Seiten, nach denen zuvor ausgeführte Schreibvorgänge auf die Festplatte geschrieben werden. | – |
| backslash\$1quote | Legt fest, ob \$1\$1 in Zeichenfolgeliteralen zulässig ist. | – |
| backtrace\$1functions | Protokollrückverfolgung für Fehler in diesen Funktionen. | – |
| bytea\$1output | Legt das Ausgabeformat für bytea fest. | – |
| check\$1function\$1bodies | Überprüft die Funktionstexte während CREATE FUNCTION. | – |
| client\$1connection\$1check\$1interval | Legt das Zeitintervall zwischen Prüfungen auf Verbindungsabbrüche während der Ausführung von Abfragen fest. | – |
| client\$1encoding | Legt die Zeichensatzkodierung des Clients fest. | UTF8 |
| client\$1min\$1messages | Legt die Nachrichtenebenen fest, die an den Client gesendet werden. | – |
| compute\$1query\$1id | Abfrage-IDs berechnen. | auto |
| config\$1file | Legt die Hauptkonfigurationsdatei des Servers fest. | /.conf rdsdbdata/config/postgresql |
| constraint\$1exclusion | Ermöglicht dem Planer die Verwendung von Einschränkungen, um Abfragen zu optimieren. | – |
| cpu\$1index\$1tuple\$1cost | Legt die Schätzung des Planers für die Kosten der Verarbeitung der einzelnen Indexeinträge während einer Indexprüfung fest. | – |
| cpu\$1operator\$1cost | Legt die Schätzung des Planers für die Kosten der Verarbeitung der einzelnen Operator- oder Funktionsaufrufe fest. | – |
| cpu\$1tuple\$1cost | Legt die Schätzung des Planers für die Kosten der Verarbeitung der einzelnen Tupeln (Zeilen) fest. | – |
| cron.database\$1name | Legt die Datenbank fest, um pg\$1cron-Metadatentabellen zu speichern | postgres |
| cron.log\$1run | Protokolliert alle Aufträge in der Tabelle job\$1run\$1details | on |
| cron.log\$1statement | Protokolliert alle Cron-Anweisungen vor der Ausführung. | aus |
| cron.max\$1running\$1jobs | Die maximale Anzahl von Aufträgen, die gleichzeitig ausgeführt werden können. | 5 |
| cron.use\$1background\$1workers | Aktiviert Hintergrund-Workers für pg\$1cron | on |
| cursor\$1tuple\$1fraction | Legt die Schätzung des Planers für den Bruchteil der Zeilen eines Cursors fest, die abgerufen werden. | – |
| data\$1directory | Legt das Datenverzeichnis des Servers fest. | /rdsdbdata/db |
| datestyle | Legt das Anzeigeformat für Datum- und Uhrzeitwerte fest. | – |
| db\$1user\$1namespace | Aktiviert Benutzernamen pro Datenbank. | – |
| deadlock\$1timeout | (ms) Legt die Zeit fest, die während einer Sperre gewartet wird, bevor auf einen Deadlock geprüft wird. | – |
| debug\$1pretty\$1print | Erstellt Einschübe für Analyse- und Planstrukturanzeigen. | – |
| debug\$1print\$1parse | Protokolliert die Analysestruktur der einzelnen Abfragen. | – |
| debug\$1print\$1plan | Protokolliert den Ausführungsplan der einzelnen Abfragen. | – |
| debug\$1print\$1rewritten | Protokolliert die neu geschriebene Analysestruktur der einzelnen Abfragen. | – |
| default\$1statistics\$1target | Legt das Standardstatistikziel fest. | – |
| default\$1tablespace | Legt den Standardtabellenraum fest, in dem Tabellen und Indexe erstellt werden. | – |
| default\$1toast\$1compression | Legt die Standardkomprimierungsmethode für komprimierbare Werte fest. | – |
| default\$1transaction\$1deferrable | Legt den Standardaufschiebbarkeitsstatus neuer Transaktionen fest. | – |
| default\$1transaction\$1isolation | Legt die Transaktionsisolierungsstufe jeder neuen Transaktion fest. | – |
| default\$1transaction\$1read\$1only | Legt den Standardschreibschutzstatus neuer Transaktionen fest. | – |
| effective\$1cache\$1size | (8 kB) Legt die Annahme des Planers hinsichtlich der Größe des Datenträger-Caches fest. | SUMME (DBInstanceClassMemory/12038, -50003) |
| effective\$1io\$1concurrency | Die Anzahl der gleichzeitigen Anfragen, die durch das Datenträgersubsystem effizient bearbeitet werden können. | – |
| enable\$1async\$1append | Ermöglicht den Planern die Verwendung paralleler Append-Pläne. | – |
| enable\$1bitmapscan | Ermöglicht die Verwendung von Bitmap-Prüfungsplänen durch den Planer. | – |
| enable\$1gathermerge | Ermöglicht die Verwendung von Gather-Merge-Plänen durch den Planer. | – |
| enable\$1hashagg | Ermöglicht die Verwendung von Hash-Aggregationsplänen durch den Planer. | – |
| enable\$1hashjoin | Ermöglicht die Verwendung von Hash-Join-Plänen durch den Planer. | – |
| enable\$1incremental\$1sort | Ermöglicht den Planern die Verwendung inkrementeller Sortierschritte. | – |
| enable\$1indexonlyscan | Ermöglicht den Planern die Verwendung von Plänen. index-only-scan | – |
| enable\$1indexscan | Ermöglicht die Verwendung von Indexprüfungsplänen durch den Planer. | – |
| enable\$1material | Ermöglicht die Verwendung von Materialisierung durch den Planer. | – |
| enable\$1memoize | Ermöglicht den Planern die Verwendung der Speicherung | – |
| enable\$1mergejoin | Ermöglicht die Verwendung von Merge-Join-Plänen durch den Planer. | – |
| enable\$1nestloop | Ermöglicht die Verwendung von Join-Plänen mit verschachtelten Schleifen durch den Planer. | – |
| enable\$1parallel\$1append | Ermöglicht den Planern die Verwendung paralleler Append-Pläne. | – |
| enable\$1parallel\$1hash | Ermöglicht den Planern die Verwendung paralleler Hash-Pläne. | – |
| enable\$1partition\$1pruning | Aktivieren Sie das Bereinigen von Planzeit- und Laufzeitpartitionen. | – |
| enable\$1partitionwise\$1aggregate | Ermöglicht die partitionsweise Aggregation und Gruppierung. | – |
| enable\$1partitionwise\$1join | Aktiviert partitionsweise Joins. | – |
| enable\$1seqscan | Ermöglicht die Verwendung von sequenziellen Prüfungsplänen durch den Planer. | – |
| enable\$1sort | Ermöglicht die Verwendung von expliziten Sortierschritten durch den Planer. | – |
| enable\$1tidscan | Ermöglicht die Verwendung von TID-Prüfungsplänen durch den Planer. | – |
| escape\$1string\$1warning | Warnt vor Escape-Notierungen mit Backslash in gewöhnlichen Zeichenfolgeliteralen. | – |
| exit\$1on\$1error | Beendet die Sitzung bei einem Fehler. | – |
| extra\$1float\$1digits | Legt die Anzahl der Stellen fest, die für Gleitkommawerte angezeigt werden. | – |
| force\$1parallel\$1mode | Erzwingt die Verwendung paralleler Abfrageeinrichtungen. | – |
| from\$1collapse\$1limit | Legt die Größe der FROM-Liste fest, jenseits der Unterabfragen nicht ausgeblendet werden. | – |
| geqo | Ermöglicht die genetische Abfrageoptimierung. | – |
| geqo\$1effort | GEQO: Der Aufwand, der verwendet wird, um den Standard für andere GEQO-Parameter festzulegen. | – |
| geqo\$1generations | GEQO: Die Zahl der Iterationen des Algorithmus. | – |
| geqo\$1pool\$1size | GEQO: Die Anzahl der Personen in der Population. | – |
| geqo\$1seed | GEQO: Der Seed für die zufällige Pfadauswahl. | – |
| geqo\$1selection\$1bias | GEQO: Selektiver Druck innerhalb der Population. | – |
| geqo\$1threshold | Legt den Schwellenwert für FROM-Elemente fest, jenseits derer GEQO verwendet wird. | – |
| gin\$1fuzzy\$1search\$1limit | Legt das maximal zulässige Ergebnis für die exakte Suche durch GIN fest. | – |
| gin\$1pending\$1list\$1limit | (kB) Legt die maximale Größe der ausstehenden Liste für den GIN-Index fest. | – |
| hash\$1mem\$1multiplier | Vielfaches von work\$1mem für Hash-Tabellen. | – |
| hba\$1file | Legt die hba-Konfigurationsdatei des Servers fest. | /\$1hba.conf rdsdbdata/config/pg |
| hot\$1standby\$1feedback | Ermöglicht Feedback von einem Hot Standby zum primären, um Abfragekonflikte zu vermeiden. | on |
| huge\$1pages | Reduziert den Overhead, wenn eine DB-Instance mit großen, zusammenhängenden Arbeitsspeicherblöcken arbeitet, wie sie von gemeinsam genutzten Puffern verwendet werden. Der Parameter ist standardmäßig für alle DB-Instance-Klassen aktiviert, außer t3.medium, db.t3.large, db.t4g.medium, db.t4g.large. | on |
| ident\$1file | Legt die ident-Konfigurationsdatei des Servers fest. | /rdsdbdata/config/pg\$1ident.conf |
| idle\$1in\$1transaction\$1session\$1timeout | (ms) Legt die maximal zulässige Dauer von Leerlauftransaktionen fest. | 86400000 |
| idle\$1session\$1timeout | Beendet jede Sitzung, die länger als die angegebene Zeitspanne im Leerlauf ist (d. h. auf eine Client-Abfrage gewartet hat), sich jedoch nicht innerhalb einer offenen Transaktion befindet | – |
| intervalstyle | Legt das Anzeigeformat für Intervallwerte fest. | – |
| join\$1collapse\$1limit | Legt die Größe der FROM-Liste fest, jenseits der JOIN-Konstrukte nicht auf eine Ebene gebracht werden. | – |
| krb\$1caseins\$1users | Legt fest, ob Generic Security Service API (GSSAPI)-Benutzernamen ohne Berücksichtigung von Groß- und Kleinschreibung behandelt werden sollen (true) oder nicht. Standardmäßig ist dieser Parameter auf false festgelegt, sodass Kerberos erwartet, dass bei Benutzernamen zwischen Groß- und Kleinschreibung unterschieden wird. Weitere Informationen finden Sie unter [GSSAPI-Authentifizierung](https://www.postgresql.org/docs/current/gssapi-auth.html) in der PostgreSQL-Dokumentation. | false |
| lc\$1messages | Legt die Sprache fest, in der Nachrichten angezeigt werden. | – |
| lc\$1monetary | Legt das Gebietsschema für die Formatierung von monetären Beträgen fest. | – |
| lc\$1numeric | Legt das Gebietsschema für die Formatierung von Zahlen fest. | – |
| lc\$1time | Legt das Gebietsschema für die Formatierung von Datum- und Uhrzeitwerten fest. | – |
| listen\$1addresses | Legt den Host-Namen oder die IP-Adresse(n) fest, auf die gewartet werden soll. | \$1 |
| lo\$1compat\$1privileges | Aktiviert den Abwärtskompatibilitätsmodus für Berechtigungsprüfungen für große Objekte. | 0 |
| log\$1autovacuum\$1min\$1duration | (ms) Legt die Mindestausführungszeit fest, jenseits der Aktionen für die Selbstbereinigung protokolliert werden. | 10000 |
| log\$1connections | Protokolliert jede erfolgreiche Verbindung. | – |
| log\$1destination | Legt das Ziel für die Serverprotokollausgabe fest. | stderr |
| log\$1directory | Legt das Zielverzeichnis für Protokolldateien fest. | /rdsdbdata/log/error |
| log\$1disconnections | Protokolliert das Ende einer Sitzung einschließlich der Dauer. | – |
| log\$1duration | Protokolliert die Dauer jeder abgeschlossenen SQL-Anweisung. | – |
| log\$1error\$1verbosity | Legt die Ausführlichkeit protokollierter Nachrichten fest. | – |
| log\$1executor\$1stats | Schreibt die Leistungsstatistik des Executors in das Serverprotokoll. | – |
| log\$1file\$1mode | Legt die Dateiberechtigungen für Protokolldateien fest. | 0644 |
| log\$1filename | Legt das Dateinamenmuster für Protokolldateien fest. | postgresql.log.%Y-%m-%d-%H%M |
| logging\$1collector | Startet einen Unterprozess, um die CSVLogs der STDERR-Ausgabe in Protokolldateien zu erfassen. and/or | 1 |
| log\$1hostname | Protokolliert den Hostnamen in den Verbindungsprotokollen. | 0 |
| logical\$1decoding\$1work\$1mem | (kB) So viel Speicher kann von jedem internen Neuordnungspuffer genutzt werden, bevor er auf die Festplatte geschrieben wird. | – |
| log\$1line\$1prefix | Steuert Informationen, die jeder Protokollzeile vorangestellt sind. | %t:%r:%u@%d:%p]: |
| log\$1lock\$1waits | Protokolliert lange Sperrenwartezeiten. | – |
| log\$1min\$1duration\$1sample | (ms) Legt die Mindestausführungszeit fest, jenseits der stichprobenartig Anweisungen protokolliert werden. Das Sampling wird durch log\$1statement\$1sample\$1rate bestimmt. | – |
| log\$1min\$1duration\$1statement | (ms) Legt die Mindestausführungszeit fest, jenseits der Anweisungen protokolliert werden. | – |
| log\$1min\$1error\$1statement | Veranlasst, dass alle Anweisungen, die einen Fehler auf oder jenseits dieser Stufe generieren, protokolliert werden. | – |
| log\$1min\$1messages | Legt die Nachrichtenebenen fest, die protokolliert werden. | – |
| log\$1parameter\$1max\$1length | (B) Beim Protokollieren von Anweisungen werden die protokollierten Parameterwerte auf die ersten N Byte beschränkt. | – |
| log\$1parameter\$1max\$1length\$1on\$1error | (B) Bei der Meldung eines Fehlers werden die protokollierten Parameterwerte auf die ersten N Byte beschränkt. | – |
| log\$1parser\$1stats | Schreibt die Leistungsstatistik des Parsers in das Serverprotokoll. | – |
| log\$1planner\$1stats | Schreibt die Leistungsstatistik des Planers in das Serverprotokoll. | – |
| log\$1replication\$1commands | Protokolliert jeden Replikationsbefehl. | – |
| log\$1rotation\$1age | (min) Die automatische Protokolldateirotation wird nach N Minuten ausgeführt. | 60 |
| log\$1rotation\$1size | (kB) Die automatische Protokolldateirotation wird nach N Kilobyte ausgeführt. | 100000 |
| log\$1statement | Legt den Typ der protokollierten Anweisungen fest. | – |
| log\$1statement\$1sample\$1rate | Anteil der Anweisungen, die log\$1min\$1duration\$1sample überschreiten, die protokolliert werden sollen. | – |
| log\$1statement\$1stats | Schreibt kumulative Leistungsstatistiken in das Serverprotokoll. | – |
| log\$1temp\$1files | (kB) Protokolliert die Verwendung temporärer Dateien, die größer als diese Kilobyte-Angabe sind. | – |
| log\$1timezone | Legt die Zeitzone fest, die in Protokollmeldungen verwendet werden soll. | UTC |
| log\$1transaction\$1sample\$1rate | Legt den Anteil der neuen Transaktionen fest, die protokolliert werden sollen. | – |
| log\$1truncate\$1on\$1rotation | Kürzt vorhandene Protokolldateien mit demselben Namen während der Protokollrotation. | 0 |
| maintenance\$1io\$1concurrency | Eine Variante von effective\$1io\$1concurrency, die für Wartungsarbeiten verwendet wird. | 1 |
| maintenance\$1work\$1mem | (kB) Legt den maximalen Arbeitsspeicher fest, der für Wartungsoperationen verwendet werden darf. | AM GRÖSSTEN (/63963136 \$11024,65536) DBInstance ClassMemory |
| max\$1connections | Legt die maximale Anzahl gleichzeitiger Verbindungen fest. | AM WENIGSTEN DBInstance ClassMemory (/9531392 .5000) |
| max\$1files\$1per\$1process | Legt die maximale Anzahl gleichzeitig geöffneter Dateien für die einzelnen Serverprozesse fest. | – |
| max\$1locks\$1per\$1transaction | Legt die maximale Anzahl von Sperren pro Transaktion fest. | 64 |
| max\$1logical\$1replication\$1workers | Maximale Anzahl von Worker-Prozessen für logische Replikation. | – |
| max\$1parallel\$1maintenance\$1workers | Legt die maximale Anzahl von parallelen Vorgängen pro Wartungsvorgang fest. | – |
| max\$1parallel\$1workers | Legt die maximale Anzahl von parallelen Workers fest, die gleichzeitig aktiv sein können. | AM GRÖSSTEN (\$1 VCPU/2,8) DBInstance |
| max\$1parallel\$1workers\$1per\$1gather | Legt die maximale Anzahl von parallelen Prozessen pro Executor-Knoten fest. | – |
| max\$1pred\$1locks\$1per\$1page | Legt die maximale Anzahl von prädikatsgesperrten Tupeln pro Seite fest. | – |
| max\$1pred\$1locks\$1per\$1relation | Legt die maximale Anzahl von prädikatsgesperrten Seiten und Tupeln pro Beziehung fest. | – |
| max\$1pred\$1locks\$1per\$1transaction | Legt die maximale Anzahl von Prädikatssperren pro Transaktion fest. | – |
| max\$1prepared\$1transactions | Legt die maximale Anzahl gleichzeitig vorbereiteter Transaktionen fest. | 0 |
| max\$1replication\$1slots | Legt die maximale Anzahl von Replikations-Slots fest, die der Server unterstützen kann. | 20 |
| max\$1slot\$1wal\$1keep\$1size | (MB) Replikations-Slots werden als fehlgeschlagen gekennzeichnet und Segmente werden zum Löschen oder Recycling freigegeben, wenn WAL auf der Festplatte so viel Speicherplatz belegt. | – |
| max\$1stack\$1depth | (kB) Legt die maximale Stack-Tiefe in Kilobytes fest. | 6144 |
| max\$1standby\$1streaming\$1delay | (ms) Legt die maximale Verzögerung fest, bevor Abfragen storniert werden, wenn ein Hot-Standby-Server gestreamte WAL-Daten verarbeitet. | 14000 |
| max\$1sync\$1workers\$1per\$1subscription | Maximale Anzahl von Synchronisations-Workers pro Abonnement | 2 |
| max\$1wal\$1senders | Legt die maximale Anzahl gleichzeitig ausgeführter WAL-Senderprozesses fest. | 10 |
| max\$1worker\$1processes | Legt die maximale Anzahl gleichzeitiger Worker-Prozesse fest. | AM GRÖSSTEN (\$1 VCPU\$12,8) DBInstance |
| min\$1dynamic\$1shared\$1memory | (MB) Menge des dynamischen gemeinsam genutzten Speichers, der beim Start reserviert wurde. | – |
| min\$1parallel\$1index\$1scan\$1size | (8 kB) Legt die Mindestmenge an Indexdaten für einen parallelen Scan fest. | – |
| min\$1parallel\$1table\$1scan\$1size | (8 kB) Legt die Mindestmenge an Tabellendaten für einen parallelen Scan fest. | – |
| old\$1snapshot\$1threshold | (min) Zeit, bis ein Snapshot zu alt ist, um Seiten zu lesen, die nach dem Erstellen des Snapshots geändert wurden. | – |
| orafce.nls\$1date\$1format | Emuliert das Datumsausgabeverhalten von Oracle. | – |
| orafce.timezone | Gibt die für die Funktion sysdate verwendete Zeitzone an. | – |
| parallel\$1leader\$1participation | Steuert, ob Gather und Gather Merge auch Unterpläne ausführen. | – |
| parallel\$1setup\$1cost | Legt die Kostenschätzung des Planers für das Starten von Worker-Prozessen für parallele Abfragen fest. | – |
| parallel\$1tuple\$1cost | Legt die Kostenschätzung des Planers für die Übergabe von Tupeln (Zeilen) von Worker auf Haupt-Backend fest. | – |
| password\$1encryption | Verschlüsselt Passwörter. | – |
| pgaudit.log | Gibt an, welche Klassen von Anweisungen durch die Sitzungsprüfungs-Protokollierung protokolliert werden. | – |
| pgaudit.log\$1catalog | Gibt an, dass die Sitzungsprotokollierung aktiviert werden soll, wenn sich alle Beziehungen in einer Anweisung in pg\$1catalog befinden. | – |
| pgaudit.log\$1level | Gibt die Protokollstufe an, die für Protokolleinträge verwendet wird. | – |
| pgaudit.log\$1parameter | Gibt an, dass die Audit-Protokollierung die Parameter enthalten sollte, die mit der Anweisung übergeben wurden. | – |
| pgaudit.log\$1relation | Gibt an, ob die Sitzungsprüfungs-Protokollierung für jede Beziehung (TABLE, VIEW usw.), auf die in einer SELECT- oder DML-Anweisung verwiesen wird, einen separaten Protokolleintrag erstellen soll. | – |
| pgaudit.log\$1statement\$1once | Gibt an, ob die Protokollierung den Anweisungstext und die Parameter beim ersten Protokolleintrag für eine statement/substatement Kombination oder bei jedem Eintrag enthält. | – |
| pgaudit.role | Gibt die Hauptrolle an, die für die Objektüberwachungsprotokollierung verwendet werden soll. | – |
| pg\$1bigm.enable\$1recheck | Gibt an, ob Recheck durchgeführt werden soll, was ein interner Prozess der Volltextsuche ist. | on |
| pg\$1bigm.gin\$1key\$1limit | Gibt die maximale Anzahl von Bigrammen des Suchschlüsselworts an, das für die Volltextsuche verwendet werden soll. | 0 |
| pg\$1bigm.last\$1update | Meldet das letzte Aktualisierungsdatum des pg\$1bigm-Moduls. | 2013.11.22 |
| pg\$1bigm.similarity\$1limit | Es gibt den Mindestschwellenwert an, der von der Ähnlichkeitssuche verwendet wird. | 0.3 |
| pg\$1hint\$1plan.debug\$1print | Protokolliert Ergebnisse der Hinweisanalyse. | – |
| pg\$1hint\$1plan.enable\$1hint | Zwingt Planer zur Verwendung der Pläne, die im Hinweiskommentar vor der Abfrage angegeben sind. | – |
| pg\$1hint\$1plan.enable\$1hint\$1table | Zwingt Planer, Hinweise nicht über Tabellensuchen zu erhalten. | – |
| pg\$1hint\$1plan.message\$1level | Nachrichtenebene von Debug-Meldungen. | – |
| pg\$1hint\$1plan.parse\$1messages | Nachrichtenebene von Analysefehlern. | – |
| pglogical.batch\$1inserts | Batch-Inserts wenn möglich | – |
| pglogical.conflict\$1log\$1level | Legt die Protokollstufe gelöster Konflikte fest | – |
| pglogical.conflict\$1resolution | Legt die Methode zur Konfliktlösung für lösbare Konflikte fest. | – |
| pglogical.extra\$1connection\$1options | Verbindungsoptionen zum Hinzufügen zu allen Peer-Knotenverbindungen | – |
| pglogical.synchronous\$1commit | Spezifischer synchroner Commit-Wert für pglogical | – |
| pglogical.use\$1spi | Verwenden Sie SPI anstelle der Low-Level-API zum Anwenden von Änderungen | – |
| pgtle.clientauth\$1databases\$1to\$1skip | Liste der Datenbanken, die für die Clientauth-Funktion übersprungen werden sollen | – |
| pgtle.clientauth\$1db\$1name | Steuert, welche Datenbank für die Clientauth-Funktion verwendet wird | – |
| pgtle.clientauth\$1num\$1parallel\$1workers | Anzahl der Hintergrund-Worker, die für die Clientauth-Funktion verwendet werden | – |
| pgtle.clientauth\$1users\$1to\$1skip | Liste der Benutzer, die für die Clientauth-Funktion übersprungen werden sollen | – |
| pgtle.enable\$1clientauth | Aktiviert die Clientauth-Funktion | – |
| pgtle.passcheck\$1db\$1name | Legt fest, welche Datenbank für die Cluster-weite Passcheck-Funktion verwendet wird | – |
| pg\$1prewarm.autoprewarm | Startet den autoprewarm-Worker. | – |
| pg\$1prewarm.autoprewarm\$1interval | Legt das Intervall zwischen Sicherungen freigegebener Puffer fest | – |
| pg\$1similarity.block\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.block\$1threshold | Legt den Schwellenwert fest, der von der Block-Ähnlichkeitsfunktion verwendet wird. | – |
| pg\$1similarity.block\$1tokenizer | Legt den Tokenizer für die Block-Ähnlichkeitsfunktion fest. | – |
| pg\$1similarity.cosine\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.cosine\$1threshold | Legt den Schwellenwert fest, der von der Kosinus-Ähnlichkeitsfunktion verwendet wird. | – |
| pg\$1similarity.cosine\$1tokenizer | Legt den Tokenizer für die Kosinus-Ähnlichkeitsfunktion fest. | – |
| pg\$1similarity.dice\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.dice\$1threshold | Legt den Schwellenwert fest, der vom Dice-Ähnlichkeitsmaß verwendet wird | – |
| pg\$1similarity.dice\$1tokenizer | Legt den Tokenizer für das Dice-Ähnlichkeitsmaß fest. | – |
| pg\$1similarity.euclidean\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.euclidean\$1threshold | Legt den Schwellenwert fest, der vom euklidischen Ähnlichkeitsmaß verwendet wird. | – |
| pg\$1similarity.euclidean\$1tokenizer | Legt den Tokenizer für das euklidische Ähnlichkeitsmaß fest. | – |
| pg\$1similarity.hamming\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.hamming\$1threshold | Legt den Schwellenwert fest, der von der Block-Ähnlichkeitsmetrik verwendet wird. | – |
| pg\$1similarity.jaccard\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.jaccard\$1threshold | Legt den Schwellenwert fest, der vom Jaccard-Ähnlichkeitsmaß verwendet wird | – |
| pg\$1similarity.jaccard\$1tokenizer | Legt den Tokenizer für das Jaccard-Ähnlichkeitsmaß fest. | – |
| pg\$1similarity.jaro\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.jaro\$1threshold | Legt den Schwellenwert fest, der vom Jaro-Ähnlichkeitsmaß verwendet wird | – |
| pg\$1similarity.jarowinkler\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.jarowinkler\$1threshold | Legt den Schwellenwert fest, der vom Jaro-Winkler-Ähnlichkeitsmaß verwendet wird | – |
| pg\$1similarity.levenshtein\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.levenshtein\$1threshold | Legt den Schwellenwert fest, der vom Levenshtein-Ähnlichkeitsmaß verwendet wird | – |
| pg\$1similarity.matching\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.matching\$1threshold | Legt den Schwellenwert fest, der vom Matching-Koeffizient-Ähnlichkeitsmaß verwendet wird. | – |
| pg\$1similarity.matching\$1tokenizer | Legt den Tokenizer für das Matching-Koeffizient-Ähnlichkeitsmaß fest. | – |
| pg\$1similarity.mongeelkan\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.mongeelkan\$1threshold | Legt den Schwellenwert fest, der vom Monge-Elkan-Ähnlichkeitsmaß verwendet wird | – |
| pg\$1similarity.mongeelkan\$1tokenizer | Legt den Tokenizer für das Monge-Elkan-Ähnlichkeitsmaß fest. | – |
| pg\$1similarity.nw\$1gap\$1penalty | Legt den Lückenabzug fest, der vom Ähnlichkeitsmaß Needleman-Wunsch verwendet wird. | – |
| pg\$1similarity.nw\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.nw\$1threshold | Legt den Schwellenwert fest, der vom Ähnlichkeitsmaß Needleman-Wunsch verwendet wird. | – |
| pg\$1similarity.overlap\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.overlap\$1threshold | Legt den Schwellenwert fest, der vom Überschneidungskoeffizient-Ähnlichkeitsmaß verwendet wird. | – |
| pg\$1similarity.overlap\$1tokenizer | Legt den Tokenizer für das Überschneidungskoeffizient-Ähnlichkeitsmaß fest. | – |
| pg\$1similarity.qgram\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.qgram\$1threshold | Legt den Schwellenwert fest, der vom Q-Gram-Ähnlichkeitsmaß verwendet wird | – |
| pg\$1similarity.qgram\$1tokenizer | Legt den Tokenizer für die Q-Gram-Messung fest. | – |
| pg\$1similarity.swg\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.swg\$1threshold | Legt den Schwellenwert fest, der für das Ähnlichkeitsmaß verwendet wird. Smith-Waterman-Gotoh | – |
| pg\$1similarity.sw\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.sw\$1threshold | Legt den Schwellenwert fest, der vom Smith-Waterman-Ähnlichkeitsmaß verwendet wird | – |
| pg\$1stat\$1statements.max | Legt die maximale Anzahl von Anweisungen fest, die von pg\$1stat\$1statements verfolgt werden. | – |
| pg\$1stat\$1statements.save | Speichert pg\$1stat\$1statements-Statistiken über Serverausfälle hinweg. | – |
| pg\$1stat\$1statements.track | Wählt aus, welche Anweisungen von pg\$1stat\$1statements verfolgt werden. | – |
| pg\$1stat\$1statements.track\$1planning | Wählt aus, ob die Planungsdauer von pg\$1stat\$1statements verfolgt wird. | – |
| pg\$1stat\$1statements.track\$1utility | Wählt aus, ob Dienstprogrammbefehle von pg\$1stat\$1statements verfolgt werden. | – |
| plan\$1cache\$1mode | Steuert die Planerauswahl des benutzerdefinierten oder generischen Plans. | – |
| port | Legt den TCP-Port fest, den der Server überwacht. | EndPointPort |
| postgis.gdal\$1enabled\$1drivers | Aktiviert oder deaktiviert GDAL-Treiber, die mit PostGIS in Postgres 9.3.5 und höher verwendet werden. | ENABLE\$1ALL |
| quote\$1all\$1identifiers | Fügt beim Generieren von SQL-Fragmenten allen Bezeichnern Anführungszeichen hinzu. | – |
| random\$1page\$1cost | Legt die Schätzung des Planers für die Kosten einer nicht sequenziell abgerufenen Datenträgerseite fest. | – |
| rdkit.dice\$1threshold | Unterer Schwellenwert der Dice-Ähnlichkeit. Moleküle mit einer Ähnlichkeit unter dem Schwellenwert sind durch die Operation \$1 nicht ähnlich. | – |
| rdkit.do\$1chiral\$1sss | Ob Stereochemie beim Unterstrukturabgleich berücksichtigt wird. Bei false werden keine Stereochemie-Informationen für den Unterstrukturabgleich verwendet. | – |
| rdkit.tanimoto\$1threshold | Unterer Schwellenwert der Tanimoto-Ähnlichkeit. Moleküle mit einer Ähnlichkeit unter dem Schwellenwert sind durch die Operation % nicht ähnlich. | – |
| rds.accepted\$1password\$1auth\$1method | Erzwingt die Authentifizierung für Verbindungen mit lokal gespeichertem Passwort. | md5\$1scram |
| rds.adaptive\$1autovacuum | RDS-Parameter für enable/disable adaptives Autovakuum. | 1 |
| rds.babelfish\$1status | RDS-Parameter für enable/disable Babelfish für Aurora PostgreSQL. | aus |
| rds.enable\$1plan\$1management | Aktivieren oder deaktivieren der apg\$1plan\$1mgmt-Erweiterung. | 0 |
| rds.extensions | Liste von Erweiterungen, die RDS zur Verfügung stellt | 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 | Siehe Protokollmeldungen für RDS-Admin-Benutzeraktionen in Kundendatenbanken. | – |
| rds.force\$1autovacuum\$1logging\$1level | Siehe Protokollmeldungen zu Selbstbereinigungsvorgängen. | WARNUNG |
| rds.force\$1ssl | SSL-Verbindungen erzwingen. | 0 |
| rds.global\$1db\$1rpo | (s) Der Schwellenwert für das Recovery Point Objective in Sekunden, der bei Überschreitungen Commits von Benutzern blockiert. Dieser Parameter ist für Aurora-PostgreSQL-basierte globale Datenbanken vorgesehen. Belassen Sie für eine nicht-globale Datenbank den Standardwert. Weitere Informationen zur Nutzung dieses Parameters finden Sie unter [Verwalten von RPOs für Aurora PostgreSQL–basierte globale Datenbanken](aurora-global-database-disaster-recovery.md#aurora-global-database-manage-recovery). | – |
| rds.logical\$1replication | Aktiviert die logische Dekodierung. | 0 |
| rds.logically\$1replicate\$1unlogged\$1tables | Nicht protokollierte Tabellen werden logisch repliziert. | 1 |
| rds.log\$1retention\$1period | Amazon RDS löscht PostgreSQL-Protokolle, die älter als N Minuten sind. | 4320 |
| rds.pg\$1stat\$1ramdisk\$1size | Größe der Ramdisk-Statistiken in MB. Ein Wert ungleich Null richtet die Ramdisk ein. Dieser Parameter ist nur für Aurora-PostgreSQL-14-Versionen und niedriger verfügbar. | 0 |
| rds.rds\$1superuser\$1reserved\$1connections | Legt die Anzahl der Verbindungs-Slots fest, die für rds\$1superusers reserviert sind. Dieser Parameter ist nur für Version 15 und niedriger verfügbar. Weitere Informationen finden Sie in der PostgreSQL-Dokumentation unter [Reservierte Verbindungen](https://www.postgresql.org/docs/current/runtime-config-connection.html#GUC-RESERVED-CONNECTIONS). | 2 |
| rds.restrict\$1password\$1commands | Beschränkt passwortbezogene Befehle auf Mitglieder von rds\$1password | – |
| rds.superuser\$1variables | Liste der reinen Superuser-Variablen, für die wir die Änderungsanweisungen von rds\$1superuser erhöhen. | session\$1replication\$1role |
| recovery\$1init\$1sync\$1method | Legt die Methode zum Synchronisieren des Datenverzeichnisses vor der Wiederherstellung nach Abstürzen fest. | syncfs |
| remove\$1temp\$1files\$1after\$1crash | Entfernt temporäre Dateien nach dem Backend-Absturz. | 0 |
| restart\$1after\$1crash | Initialisiert den Server nach dem Backend-Absturz neu. | – |
| row\$1security | Aktiviert Zeilensicherheit. | – |
| search\$1path | Legt die Schemasuchreihenfolge für Namen fest, die nicht schemaqualifiziert sind. | – |
| seq\$1page\$1cost | Legt die Schätzung des Planers für die Kosten einer sequenziell abgerufenen Datenträgerseite fest. | – |
| session\$1replication\$1role | Legt das Sitzungsverhalten für Auslöser und Neuschreibungsregeln fest. | – |
| shared\$1buffers | (8 kB) Legt die maximale Anzahl freigegebener Arbeitsspeicherpuffer fest, die vom Server verwendet werden. | SUMME (DBInstanceClassMemory/12038, -50003) |
| shared\$1preload\$1libraries | Listet freigegebene Bibliotheken auf, die in den Server vorgeladen werden. | pg\$1stat\$1statements |
| ssl | Ermöglicht SSL-Verbindungen. | 1 |
| ssl\$1ca\$1file | Speicherort der SSL-Server-Zertifizierungsstellendatei. | rdsdbdata/rds-metadata/ca/-cert.pem |
| ssl\$1cert\$1file | Speicherort der SSL-Serverzertifikatdatei. | /rdsdbdata/rds-metadata/server-cert.pem |
| ssl\$1ciphers | Legt die Liste der zulässigen TLS-Verschlüsselungen fest, die für sichere Verbindungen verwendet werden sollen. | – |
| ssl\$1crl\$1dir | Speicherort des Verzeichnisses der SSL-Zertifikatsperrliste. | /rdsdbdata/rds-metadata/ssl\$1crl\$1dir/ |
| ssl\$1key\$1file | Speicherort der privaten Schlüsseldatei des SSL-Servers | /rdsdbdata/rds-metadata/server-key.pem |
| ssl\$1max\$1protocol\$1version | Legt die maximal zulässige Protokollversion fest SSL/TLS | – |
| ssl\$1min\$1protocol\$1version | Legt die zulässige Mindestversion SSL/TLS des Protokolls fest | TLSv12. |
| standard\$1conforming\$1strings | Veranlasst Zeichenfolgen „...“, Backslashes als Zeichen zu behandeln. | – |
| statement\$1timeout | (ms) Legt die maximal zulässige Dauer von Anweisungen fest. | – |
| stats\$1temp\$1directory | Schreibt temporäre Statistikdateien in das angegebene Verzeichnis. | /rdsdbdata/db/pg\$1stat\$1tmp |
| superuser\$1reserved\$1connections | Legt die Anzahl der Verbindungs-Slots fest, die für Superusers reserviert sind. | 3 |
| synchronize\$1seqscans | Ermöglicht synchronisierte sequenzielle Prüfungen. | – |
| synchronous\$1commit | Legt die Synchronisierungsstufe aktueller Transaktionen fest. | on |
| tcp\$1keepalives\$1count | Maximale Anzahl von TCP-Keepalive-Neuübertragungen. | – |
| tcp\$1keepalives\$1idle | (s) Zeit zwischen der Ausgabe von TCP-Keepalives. | – |
| tcp\$1keepalives\$1interval | (s) Zeit zwischen der Ausgabe von TCP-Keepalive-Neuübertragungen. | – |
| temp\$1buffers | (8 kB) Legt die maximale Anzahl der temporären Puffer fest, die von den einzelnen Sitzungen verwendet werden. | – |
| temp\$1file\$1limit | Schränkt den Gesamtspeicherplatz in Kilobyte ein, den ein bestimmter PostgreSQL-Prozess für temporäre Dateien verwenden kann, ausschließlich von Speicherplatz, der für explizite temporäre Tabellen verwendet wird | -1 |
| temp\$1tablespaces | Legt die Tabellenräume fest, die für temporäre Tabellen und Sortierdateien verwendet werden sollen. | – |
| timezone | Legt die Zeitzone für die Anzeige und Interpretation von Zeitstempeln fest. | UTC |
| track\$1activities | Sammelt Informationen zu Befehlen, die ausgeführt werden. | – |
| track\$1activity\$1query\$1size | Legt die für pg\$1stat\$1activity.current\$1query reservierte Größe in Bytes fest. | 4096 |
| track\$1commit\$1timestamp | Erfasst den Commit-Zeitpunkt der Transaktion. | – |
| track\$1counts | Sammelt Statistiken zur Datenbankaktivität. | – |
| track\$1functions | Sammelt Statistiken auf Funktionsebene zur Datenbankaktivität. | pl |
| track\$1io\$1timing | Erfasst Zeitpunktstatistiken zur Datenbank-E/A-Aktivität. | 1 |
| track\$1wal\$1io\$1timing | Erfasst Zeitpunktstatistiken zur WAL-E/A-Aktivität. | – |
| transform\$1null\$1equals | Behandelt expr=NULL als expr IS NULL. | – |
| update\$1process\$1title | Aktualisiert den Titel des Vorgangs, um den aktiven SQL-Befehl anzuzeigen. | – |
| vacuum\$1cost\$1delay | (ms) Bereinigungskostenverzögerung in Millisekunden. | – |
| vacuum\$1cost\$1limit | Bereinigungskostenbetrag, der vor der Inaktivität verfügbar ist. | – |
| vacuum\$1cost\$1page\$1dirty | Bereinigungskosten für eine Seite, die durch eine Bereinigung ungültig wurde. | – |
| vacuum\$1cost\$1page\$1hit | Bereinigungskosten für eine Seite, die im Puffer-Cache gefunden wurde. | – |
| vacuum\$1cost\$1page\$1miss | Bereinigungskosten für eine Seite, die nicht im Puffer-Cache gefunden wurde. | 0 |
| vacuum\$1defer\$1cleanup\$1age | Anzahl der Transaktionen, um die VACUUM und HOT Cleanup aufgeschoben werden sollen, wenn vorhanden. | – |
| vacuum\$1failsafe\$1age | Alter, bei dem der VACUUM-Vorgang die Ausfallsicherheit auslösen sollte, um einen Wraparound-Ausfall zu vermeiden. | 1200000000 |
| vacuum\$1freeze\$1min\$1age | Mindestalter, bei dem der VACUUM-Vorgang eine Tabellenzeile eingefroren werden sollte. | – |
| vacuum\$1freeze\$1table\$1age | Alter, bei dem der VACUUM-Vorgang eine Tabelle vollständig scannen sollte, um Tupel einzufrieren. | – |
| vacuum\$1multixact\$1failsafe\$1age | Multixact-Alter, bei dem der VACUUM-Vorgang die Ausfallsicherheit auslösen sollte, um einen Wraparound-Ausfall zu vermeiden. | 1200000000 |
| vacuum\$1multixact\$1freeze\$1min\$1age | Mindestalter, ab dem VACUUM eine Zahl MultiXactId in einer Tabellenzeile einfrieren soll. | – |
| vacuum\$1multixact\$1freeze\$1table\$1age | Multixact-Alter, bei dem der VACUUM-Vorgang eine Tabelle vollständig scannen sollte, um Tupel einzufrieren. | – |
| wal\$1buffers | (8 kB) Legt die Anzahl von Datenträger-Seitenpuffern im freigegebenen Arbeitsspeicher für WAL fest. | – |
| wal\$1receiver\$1create\$1temp\$1slot | Legt fest, ob ein WAL-Receiver einen temporären Replikations-Slot erstellen soll, wenn kein permanenter Slot konfiguriert ist. | 0 |
| wal\$1receiver\$1status\$1interval | (s) Legt das maximale Intervall zwischen den Statusberichten des WAL-Receivers auf den primären Wert fest. | – |
| wal\$1receiver\$1timeout | (ms) Legt die maximale Wartezeit fest, um Daten von der Primär-Instance zu empfangen. | 30000 |
| wal\$1sender\$1timeout | (ms) Legt fest, wie lange höchstens auf die WAL-Replikation gewartet wird. | – |
| work\$1mem | (kB) Legt den maximalen Arbeitsspeicher fest, der für Abfrage-Workspaces verwendet werden darf. | – |
| xmlbinary | Legt die Kodierung von Binärwerten in XML fest. | – |
| xmloption | Legt fest, ob XML-Daten in impliziten Parsing- und Serialisierungsoperationen als Dokumente oder Inhaltsfragmente betrachtet werden sollen. | – |
## Aurora-PostgreSQL-Parameter auf Instance-Ebene
Sie können die Parameter auf Instanzebene, die für eine bestimmte Aurora PostgreSQL-Version verfügbar sind, mithilfe der AWS Management-Konsole, der AWS CLI oder der Amazon RDS-API anzeigen. Weitere Informationen zum Anzeigen von Parametern in einer DB-Parametergruppe von Aurora PostgreSQL finden Sie unter [Anzeigen von Parameterwerten für eine DB-Parametergruppe in Amazon Aurora](USER_WorkingWithParamGroups.Viewing.md).
Einige Parameter auf Instance-Ebene sind nicht in allen Versionen verfügbar und manche sind veraltet. Hinweise zum Anzeigen der Parameter einer bestimmten Aurora-PostgreSQL-Version finden Sie unter [Anzeigen von Aurora-PostgreSQL-DB-Cluster- und DB-Parametern](#AuroraPostgreSQL.Reference.ParameterGroups-viewing-parameters).
In der folgenden Tabelle werden beispielsweise alle Parameter aufgeführt, die für eine bestimmte DB-Instance in einem DB-Cluster von Aurora PostgreSQL gelten. Diese Liste wurde generiert, indem der [describe-db-parameters](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-parameters.html) AWS CLI Befehl mit `default.aurora-postgresql14` für den Wert ausgeführt wurde. `--db-parameter-group-name`
Eine Auflistung der DB-Cluster-Parameter für dieselbe Standard-DB-Parametergruppe finden Sie unter [Aurora-PostgreSQL-Parameter auf Cluster-Ebene](#AuroraPostgreSQL.Reference.Parameters.Cluster).
| Parametername | Description | Standard |
| --- | --- | --- |
| apg\$1enable\$1batch\$1mode\$1function\$1execution | Aktiviert Batch-Modus-Funktionen, um mehrere Zeilen gleichzeitig zu verarbeiten. | – |
| apg\$1enable\$1correlated\$1any\$1transform | Ermöglicht es dem Planer, korrelierte ANY-Sublinks (IN/NOT IN Unterabfrage) nach Möglichkeit in JOIN umzuwandeln. | – |
| apg\$1enable\$1function\$1migration | Ermöglicht dem Planer, berechtigte Skalarfunktionen in die FROM-Klausel zu migrieren. | – |
| apg\$1enable\$1not\$1in\$1transform | Ermöglicht es dem Planer, NOT IN-Unterabfragen nach Möglichkeit in ANTI JOIN umzuwandeln. | – |
| apg\$1enable\$1remove\$1redundant\$1inner\$1joins | Ermöglicht dem Planer, redundante Inner Joins zu entfernen. | – |
| apg\$1enable\$1semijoin\$1push\$1down | Ermöglicht die Verwendung von Semijoin-Filtern für Hash-Joins. | – |
| apg\$1plan\$1mgmt.capture\$1plan\$1baselines | Baseline-Modus für Planerfassung. Manuell – Planerfassung für jede SQL-Anweisung aktivieren. Aus – Planerfassung deaktivieren. Automatisch – Planerfassung für Anweisungen in pg\$1stat\$1statement aktivieren, die die Berechtigungskriterien erfüllen. | aus |
| apg\$1plan\$1mgmt.max\$1databases | Legt die maximale Anzahl von Datenbanken fest, die Abfragen mit apg\$1plan\$1mgmt verwalten können. | 10 |
| apg\$1plan\$1mgmt.max\$1plans | Legt die maximale Anzahl von Plänen fest, die von apg\$1plan\$1mgmt zwischengespeichert werden können. | 10000 |
| apg\$1plan\$1mgmt.plan\$1retention\$1period | Maximale Anzahl von Tagen, seit ein Plan zuletzt verwendet wurde, bevor ein Plan automatisch gelöscht wird. | 32 |
| apg\$1plan\$1mgmt.unapproved\$1plan\$1execution\$1threshold | Geschätzte Gesamtplankosten, unter denen ein nicht genehmigter Plan ausgeführt wird. | 0 |
| apg\$1plan\$1mgmt.use\$1plan\$1baselines | Verwenden Sie nur genehmigte oder feste Pläne für verwaltete Anweisungen. | false |
| application\$1name | Legt den Namen der Anwendung fest, der in Statistiken und Protokollen verwendet werden soll. | – |
| aurora\$1compute\$1plan\$1id | Überwacht Ausführungspläne von Abfragen, um die Ausführungspläne zu ermitteln, die zur aktuellen Datenbanklast beitragen, und um Leistungsstatistiken der Ausführungspläne im Laufe der Zeit zu verfolgen Weitere Informationen finden Sie unter [Überwachen von Abfrageausführungsplänen für Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraPostgreSQL.Monitoring.Query.Plans.html). | on |
| aurora\$1temp\$1space\$1size | (MB) Legt die Größe des zugewiesenen Speicherplatzes für temporäre Objekte mit aktivierten optimierten Lesevorgängen auf E/A-optimierten Aurora-Clustern mit unterstützten Instance-Klassen fest | DBInstanceClassMemory/524288 |
| authentication\$1timeout | (s) Legt die Zeit fest, die maximal zulässig ist, um die Client-Authentifizierung durchzuführen. | – |
| auto\$1explain.log\$1analyze | Verwenden Sie EXPLAIN ANALYZE zur Planprotokollierung. | – |
| auto\$1explain.log\$1buffers | Protokollieren der Puffernutzung. | – |
| auto\$1explain.log\$1format | EXPLAIN-Format, das für die Planprotokollierung verwendet werden soll. | – |
| auto\$1explain.log\$1min\$1duration | Legt die Mindestausführungszeit fest, ab der Pläne protokolliert werden. | – |
| auto\$1explain.log\$1nested\$1statements | Protokollieren verschachtelter Anweisungen. | – |
| auto\$1explain.log\$1timing | Erfasst Timing-Daten, nicht nur Zeilenzahlen. | – |
| auto\$1explain.log\$1triggers | Fügt Auslöserstatistiken in Pläne ein. | – |
| auto\$1explain.log\$1verbose | Verwenden Sie EXPLAIN VERBOSE zur Planprotokollierung. | – |
| auto\$1explain.sample\$1rate | Bruchteil der zu verarbeitenden Abfragen. | – |
| babelfishpg\$1tds.listen\$1adressen | Legt den Host-Namen oder die IP-Adresse(n) fest, die auf TDS überwacht werden sollen. | \$1 |
| babelfishpg\$1tds.tds\$1debug\$1log\$1level | Legt die Protokollierungsstufe in TDS fest, 0 deaktiviert die Protokollierung | 1 |
| backend\$1flush\$1after | (8 Kb) Anzahl der Seiten, nach denen zuvor ausgeführte Schreibvorgänge auf die Festplatte geschrieben werden. | – |
| bytea\$1output | Legt das Ausgabeformat für bytea fest. | – |
| check\$1function\$1bodies | Überprüft die Funktionstexte während CREATE FUNCTION. | – |
| client\$1connection\$1check\$1interval | Legt das Zeitintervall zwischen Prüfungen auf Verbindungsabbrüche während der Ausführung von Abfragen fest. | – |
| client\$1min\$1messages | Legt die Nachrichtenebenen fest, die an den Client gesendet werden. | – |
| config\$1file | Legt die Hauptkonfigurationsdatei des Servers fest. | /.conf rdsdbdata/config/postgresql |
| constraint\$1exclusion | Ermöglicht dem Planer die Verwendung von Einschränkungen, um Abfragen zu optimieren. | – |
| cpu\$1index\$1tuple\$1cost | Legt die Schätzung des Planers für die Kosten der Verarbeitung der einzelnen Indexeinträge während einer Indexprüfung fest. | – |
| cpu\$1operator\$1cost | Legt die Schätzung des Planers für die Kosten der Verarbeitung der einzelnen Operator- oder Funktionsaufrufe fest. | – |
| cpu\$1tuple\$1cost | Legt die Schätzung des Planers für die Kosten der Verarbeitung der einzelnen Tupeln (Zeilen) fest. | – |
| cron.database\$1name | Legt die Datenbank fest, um pg\$1cron-Metadatentabellen zu speichern | postgres |
| cron.log\$1run | Protokolliert alle Aufträge in der Tabelle job\$1run\$1details | on |
| cron.log\$1statement | Protokolliert alle Cron-Anweisungen vor der Ausführung. | aus |
| cron.max\$1running\$1jobs | Die maximale Anzahl von Aufträgen, die gleichzeitig ausgeführt werden können. | 5 |
| cron.use\$1background\$1workers | Aktiviert Hintergrund-Workers für pg\$1cron | on |
| cursor\$1tuple\$1fraction | Legt die Schätzung des Planers für den Bruchteil der Zeilen eines Cursors fest, die abgerufen werden. | – |
| db\$1user\$1namespace | Aktiviert Benutzernamen pro Datenbank. | – |
| deadlock\$1timeout | (ms) Legt die Zeit fest, die während einer Sperre gewartet wird, bevor auf einen Deadlock geprüft wird. | – |
| debug\$1pretty\$1print | Erstellt Einschübe für Analyse- und Planstrukturanzeigen. | – |
| debug\$1print\$1parse | Protokolliert die Analysestruktur der einzelnen Abfragen. | – |
| debug\$1print\$1plan | Protokolliert den Ausführungsplan der einzelnen Abfragen. | – |
| debug\$1print\$1rewritten | Protokolliert die neu geschriebene Analysestruktur der einzelnen Abfragen. | – |
| default\$1statistics\$1target | Legt das Standardstatistikziel fest. | – |
| default\$1transaction\$1deferrable | Legt den Standardaufschiebbarkeitsstatus neuer Transaktionen fest. | – |
| default\$1transaction\$1isolation | Legt die Transaktionsisolierungsstufe jeder neuen Transaktion fest. | – |
| default\$1transaction\$1read\$1only | Legt den Standardschreibschutzstatus neuer Transaktionen fest. | – |
| effective\$1cache\$1size | (8 kB) Legt die Annahme des Planers hinsichtlich der Größe des Datenträger-Caches fest. | SUMME (DBInstanceClassMemory/12038, -50003 |
| effective\$1io\$1concurrency | Die Anzahl der gleichzeitigen Anfragen, die durch das Datenträgersubsystem effizient bearbeitet werden können. | – |
| enable\$1async\$1append | Ermöglicht den Planern die Verwendung paralleler Append-Pläne. | – |
| enable\$1bitmapscan | Ermöglicht die Verwendung von Bitmap-Prüfungsplänen durch den Planer. | – |
| enable\$1gathermerge | Ermöglicht die Verwendung von Gather-Merge-Plänen durch den Planer. | – |
| enable\$1hashagg | Ermöglicht die Verwendung von Hash-Aggregationsplänen durch den Planer. | – |
| enable\$1hashjoin | Ermöglicht die Verwendung von Hash-Join-Plänen durch den Planer. | – |
| enable\$1incremental\$1sort | Ermöglicht den Planern die Verwendung inkrementeller Sortierschritte. | – |
| enable\$1indexonlyscan | Ermöglicht den Planern die Verwendung von Plänen. index-only-scan | – |
| enable\$1indexscan | Ermöglicht die Verwendung von Indexprüfungsplänen durch den Planer. | – |
| enable\$1material | Ermöglicht die Verwendung von Materialisierung durch den Planer. | – |
| enable\$1memoize | Ermöglicht den Planern die Verwendung der Speicherung | – |
| enable\$1mergejoin | Ermöglicht die Verwendung von Merge-Join-Plänen durch den Planer. | – |
| enable\$1nestloop | Ermöglicht die Verwendung von Join-Plänen mit verschachtelten Schleifen durch den Planer. | – |
| enable\$1parallel\$1append | Ermöglicht den Planern die Verwendung paralleler Append-Pläne. | – |
| enable\$1parallel\$1hash | Ermöglicht den Planern die Verwendung paralleler Hash-Pläne. | – |
| enable\$1partition\$1pruning | Aktivieren Sie das Bereinigen von Planzeit- und Laufzeitpartitionen. | – |
| enable\$1partitionwise\$1aggregate | Ermöglicht die partitionsweise Aggregation und Gruppierung. | – |
| enable\$1partitionwise\$1join | Aktiviert partitionsweise Joins. | – |
| enable\$1seqscan | Ermöglicht die Verwendung von sequenziellen Prüfungsplänen durch den Planer. | – |
| enable\$1sort | Ermöglicht die Verwendung von expliziten Sortierschritten durch den Planer. | – |
| enable\$1tidscan | Ermöglicht die Verwendung von TID-Prüfungsplänen durch den Planer. | – |
| escape\$1string\$1warning | Warnt vor Escape-Notierungen mit Backslash in gewöhnlichen Zeichenfolgeliteralen. | – |
| exit\$1on\$1error | Beendet die Sitzung bei einem Fehler. | – |
| force\$1parallel\$1mode | Erzwingt die Verwendung paralleler Abfrageeinrichtungen. | – |
| from\$1collapse\$1limit | Legt die Größe der FROM-Liste fest, jenseits der Unterabfragen nicht ausgeblendet werden. | – |
| geqo | Ermöglicht die genetische Abfrageoptimierung. | – |
| geqo\$1effort | GEQO: Der Aufwand, der verwendet wird, um den Standard für andere GEQO-Parameter festzulegen. | – |
| geqo\$1generations | GEQO: Die Zahl der Iterationen des Algorithmus. | – |
| geqo\$1pool\$1size | GEQO: Die Anzahl der Personen in der Population. | – |
| geqo\$1seed | GEQO: Der Seed für die zufällige Pfadauswahl. | – |
| geqo\$1selection\$1bias | GEQO: Selektiver Druck innerhalb der Population. | – |
| geqo\$1threshold | Legt den Schwellenwert für FROM-Elemente fest, jenseits derer GEQO verwendet wird. | – |
| gin\$1fuzzy\$1search\$1limit | Legt das maximal zulässige Ergebnis für die exakte Suche durch GIN fest. | – |
| gin\$1pending\$1list\$1limit | (kB) Legt die maximale Größe der ausstehenden Liste für den GIN-Index fest. | – |
| hash\$1mem\$1multiplier | Vielfaches von work\$1mem für Hash-Tabellen. | – |
| hba\$1file | Legt die hba-Konfigurationsdatei des Servers fest. | /\$1hba.conf rdsdbdata/config/pg |
| hot\$1standby\$1feedback | Ermöglicht Feedback von einem Hot Standby zum primären, um Abfragekonflikte zu vermeiden. | on |
| ident\$1file | Legt die ident-Konfigurationsdatei des Servers fest. | /rdsdbdata/config/pg\$1ident.conf |
| idle\$1in\$1transaction\$1session\$1timeout | (ms) Legt die maximal zulässige Dauer von Leerlauftransaktionen fest. | 86400000 |
| idle\$1session\$1timeout | Beendet jede Sitzung, die länger als die angegebene Zeitspanne im Leerlauf ist (d. h. auf eine Client-Abfrage gewartet hat), sich jedoch nicht innerhalb einer offenen Transaktion befindet | – |
| join\$1collapse\$1limit | Legt die Größe der FROM-Liste fest, jenseits der JOIN-Konstrukte nicht auf eine Ebene gebracht werden. | – |
| lc\$1messages | Legt die Sprache fest, in der Nachrichten angezeigt werden. | – |
| listen\$1addresses | Legt den Host-Namen oder die IP-Adresse(n) fest, auf die gewartet werden soll. | \$1 |
| lo\$1compat\$1privileges | Aktiviert den Abwärtskompatibilitätsmodus für Berechtigungsprüfungen für große Objekte. | 0 |
| log\$1connections | Protokolliert jede erfolgreiche Verbindung. | – |
| log\$1destination | Legt das Ziel für die Serverprotokollausgabe fest. | stderr |
| log\$1directory | Legt das Zielverzeichnis für Protokolldateien fest. | /rdsdbdata/log/error |
| log\$1disconnections | Protokolliert das Ende einer Sitzung einschließlich der Dauer. | – |
| log\$1duration | Protokolliert die Dauer jeder abgeschlossenen SQL-Anweisung. | – |
| log\$1error\$1verbosity | Legt die Ausführlichkeit protokollierter Nachrichten fest. | – |
| log\$1executor\$1stats | Schreibt die Leistungsstatistik des Executors in das Serverprotokoll. | – |
| log\$1file\$1mode | Legt die Dateiberechtigungen für Protokolldateien fest. | 0644 |
| log\$1filename | Legt das Dateinamenmuster für Protokolldateien fest. | postgresql.log.%Y-%m-%d-%H%M |
| logging\$1collector | Startet einen Unterprozess, um die CSVLogs der STDERR-Ausgabe in Protokolldateien zu erfassen. and/or | 1 |
| log\$1hostname | Protokolliert den Hostnamen in den Verbindungsprotokollen. | 0 |
| logical\$1decoding\$1work\$1mem | (kB) So viel Speicher kann von jedem internen Neuordnungspuffer genutzt werden, bevor er auf die Festplatte geschrieben wird. | – |
| log\$1line\$1prefix | Steuert Informationen, die jeder Protokollzeile vorangestellt sind. | %t:%r:%u@%d:%p]: |
| log\$1lock\$1waits | Protokolliert lange Sperrenwartezeiten. | – |
| log\$1min\$1duration\$1sample | (ms) Legt die Mindestausführungszeit fest, jenseits der Anweisungen stichprobenartig protokolliert werden. Das Sampling wird durch log\$1statement\$1sample\$1rate bestimmt. | – |
| log\$1min\$1duration\$1statement | (ms) Legt die Mindestausführungszeit fest, jenseits der Anweisungen protokolliert werden. | – |
| log\$1min\$1error\$1statement | Veranlasst, dass alle Anweisungen, die einen Fehler auf oder jenseits dieser Stufe generieren, protokolliert werden. | – |
| log\$1min\$1messages | Legt die Nachrichtenebenen fest, die protokolliert werden. | – |
| log\$1parameter\$1max\$1length | (B) Beim Protokollieren von Anweisungen werden die protokollierten Parameterwerte auf die ersten N Byte beschränkt. | – |
| log\$1parameter\$1max\$1length\$1on\$1error | (B) Bei der Meldung eines Fehlers werden die protokollierten Parameterwerte auf die ersten N Byte beschränkt. | – |
| log\$1parser\$1stats | Schreibt die Leistungsstatistik des Parsers in das Serverprotokoll. | – |
| log\$1planner\$1stats | Schreibt die Leistungsstatistik des Planers in das Serverprotokoll. | – |
| log\$1replication\$1commands | Protokolliert jeden Replikationsbefehl. | – |
| log\$1rotation\$1age | (min) Die automatische Protokolldateirotation wird nach N Minuten ausgeführt. | 60 |
| log\$1rotation\$1size | (kB) Die automatische Protokolldateirotation wird nach N Kilobyte ausgeführt. | 100000 |
| log\$1statement | Legt den Typ der protokollierten Anweisungen fest. | – |
| log\$1statement\$1sample\$1rate | Anteil der Anweisungen, die log\$1min\$1duration\$1sample überschreiten, die protokolliert werden sollen. | – |
| log\$1statement\$1stats | Schreibt kumulative Leistungsstatistiken in das Serverprotokoll. | – |
| log\$1temp\$1files | (kB) Protokolliert die Verwendung temporärer Dateien, die größer als diese Kilobyte-Angabe sind. | – |
| log\$1timezone | Legt die Zeitzone fest, die in Protokollmeldungen verwendet werden soll. | UTC |
| log\$1truncate\$1on\$1rotation | Kürzt vorhandene Protokolldateien mit demselben Namen während der Protokollrotation. | 0 |
| maintenance\$1io\$1concurrency | Eine Variante von effective\$1io\$1concurrency, die für Wartungsarbeiten verwendet wird. | 1 |
| maintenance\$1work\$1mem | (kB) Legt den maximalen Arbeitsspeicher fest, der für Wartungsoperationen verwendet werden darf. | AM GRÖSSTEN DBInstance ClassMemory (/63963136 \$11024,65536) |
| max\$1connections | Legt die maximale Anzahl gleichzeitiger Verbindungen fest. | AM WENIGSTEN (DBInstanceClassMemory/9531392 ,5000) |
| max\$1files\$1per\$1process | Legt die maximale Anzahl gleichzeitig geöffneter Dateien für die einzelnen Serverprozesse fest. | – |
| max\$1locks\$1per\$1transaction | Legt die maximale Anzahl von Sperren pro Transaktion fest. | 64 |
| max\$1parallel\$1maintenance\$1workers | Legt die maximale Anzahl von parallelen Vorgängen pro Wartungsvorgang fest. | – |
| max\$1parallel\$1workers | Legt die maximale Anzahl von parallelen Workers fest, die gleichzeitig aktiv sein können. | AM GRÖSSTEN (\$1 DBInstance VCPU/2,8 |
| max\$1parallel\$1workers\$1per\$1gather | Legt die maximale Anzahl von parallelen Prozessen pro Executor-Knoten fest. | – |
| max\$1pred\$1locks\$1per\$1page | Legt die maximale Anzahl von prädikatsgesperrten Tupeln pro Seite fest. | – |
| max\$1pred\$1locks\$1per\$1relation | Legt die maximale Anzahl von prädikatsgesperrten Seiten und Tupeln pro Beziehung fest. | – |
| max\$1pred\$1locks\$1per\$1transaction | Legt die maximale Anzahl von Prädikatssperren pro Transaktion fest. | – |
| max\$1slot\$1wal\$1keep\$1size | (MB) Replikationsslots werden als fehlgeschlagen gekennzeichnet und Segmente zum Löschen oder Recycling freigegeben, wenn WAL auf der Festplatte so viel Speicherplatz belegt. | – |
| max\$1stack\$1depth | (kB) Legt die maximale Stack-Tiefe in Kilobyte fest. | 6144 |
| max\$1standby\$1streaming\$1delay | (ms) Legt die maximale Verzögerung fest, bevor Abfragen storniert werden, wenn ein Hot-Standby-Server gestreamte WAL-Daten verarbeitet. | 14000 |
| max\$1worker\$1processes | Legt die maximale Anzahl gleichzeitiger Worker-Prozesse fest. | AM GRÖSSTEN (\$1 VCPU\$12,8 DBInstance |
| min\$1dynamic\$1shared\$1memory | (MB) Menge des dynamischen gemeinsam genutzten Speichers, der beim Start reserviert wurde. | – |
| min\$1parallel\$1index\$1scan\$1size | (8 kB) Legt die Mindestmenge an Indexdaten für einen parallelen Scan fest. | – |
| min\$1parallel\$1table\$1scan\$1size | (8 kB) Legt die Mindestmenge an Tabellendaten für einen parallelen Scan fest. | – |
| old\$1snapshot\$1threshold | (min) Zeit, bis ein Snapshot zu alt ist, um Seiten zu lesen, die nach dem Erstellen des Snapshots geändert wurden. | – |
| parallel\$1leader\$1participation | Steuert, ob Gather und Gather Merge auch Unterpläne ausführen. | – |
| parallel\$1setup\$1cost | Legt die Kostenschätzung des Planers für das Starten von Worker-Prozessen für parallele Abfragen fest. | – |
| parallel\$1tuple\$1cost | Legt die Kostenschätzung des Planers für die Übergabe von Tupeln (Zeilen) von Worker auf Haupt-Backend fest. | – |
| pgaudit.log | Gibt an, welche Klassen von Anweisungen durch die Sitzungsprüfungs-Protokollierung protokolliert werden. | – |
| pgaudit.log\$1catalog | Gibt an, dass die Sitzungsprotokollierung aktiviert werden soll, wenn sich alle Beziehungen in einer Anweisung in pg\$1catalog befinden. | – |
| pgaudit.log\$1level | Gibt die Protokollstufe an, die für Protokolleinträge verwendet wird. | – |
| pgaudit.log\$1parameter | Gibt an, dass die Audit-Protokollierung die Parameter enthalten sollte, die mit der Anweisung übergeben wurden. | – |
| pgaudit.log\$1relation | Gibt an, ob die Sitzungsprüfungs-Protokollierung für jede Beziehung (TABLE, VIEW usw.), auf die in einer SELECT- oder DML-Anweisung verwiesen wird, einen separaten Protokolleintrag erstellen soll. | – |
| pgaudit.log\$1statement\$1once | Gibt an, ob die Protokollierung den Anweisungstext und die Parameter beim ersten Protokolleintrag für eine statement/substatement Kombination oder bei jedem Eintrag enthält. | – |
| pgaudit.role | Gibt die Hauptrolle an, die für die Objektüberwachungsprotokollierung verwendet werden soll. | – |
| pg\$1bigm.enable\$1recheck | Gibt an, ob Recheck durchgeführt werden soll, was ein interner Prozess der Volltextsuche ist. | on |
| pg\$1bigm.gin\$1key\$1limit | Gibt die maximale Anzahl von Bigrammen des Suchschlüsselworts an, das für die Volltextsuche verwendet werden soll. | 0 |
| pg\$1bigm.last\$1update | Meldet das letzte Aktualisierungsdatum des pg\$1bigm-Moduls. | 2013.11.22 |
| pg\$1bigm.similarity\$1limit | Es gibt den Mindestschwellenwert an, der von der Ähnlichkeitssuche verwendet wird. | 0.3 |
| pg\$1hint\$1plan.debug\$1print | Protokolliert Ergebnisse der Hinweisanalyse. | – |
| pg\$1hint\$1plan.enable\$1hint | Zwingt Planer zur Verwendung der Pläne, die im Hinweiskommentar vor der Abfrage angegeben sind. | – |
| pg\$1hint\$1plan.enable\$1hint\$1table | Zwingt Planer, Hinweise nicht über Tabellensuchen zu erhalten. | – |
| pg\$1hint\$1plan.message\$1level | Nachrichtenebene von Debug-Meldungen. | – |
| pg\$1hint\$1plan.parse\$1messages | Nachrichtenebene von Analysefehlern. | – |
| pglogical.batch\$1inserts | Batch-Inserts wenn möglich | – |
| pglogical.conflict\$1log\$1level | Legt die Protokollstufe gelöster Konflikte fest | – |
| pglogical.conflict\$1resolution | Legt die Methode zur Konfliktlösung für lösbare Konflikte fest. | – |
| pglogical.extra\$1connection\$1options | Verbindungsoptionen zum Hinzufügen zu allen Peer-Knotenverbindungen | – |
| pglogical.synchronous\$1commit | Spezifischer synchroner Commit-Wert für pglogical | – |
| pglogical.use\$1spi | Verwenden Sie SPI anstelle der Low-Level-API zum Anwenden von Änderungen | – |
| pg\$1similarity.block\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.block\$1threshold | Legt den Schwellenwert fest, der von der Block-Ähnlichkeitsfunktion verwendet wird. | – |
| pg\$1similarity.block\$1tokenizer | Legt den Tokenizer für die Block-Ähnlichkeitsfunktion fest. | – |
| pg\$1similarity.cosine\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.cosine\$1threshold | Legt den Schwellenwert fest, der von der Kosinus-Ähnlichkeitsfunktion verwendet wird. | – |
| pg\$1similarity.cosine\$1tokenizer | Legt den Tokenizer für die Kosinus-Ähnlichkeitsfunktion fest. | – |
| pg\$1similarity.dice\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.dice\$1threshold | Legt den Schwellenwert fest, der vom Dice-Ähnlichkeitsmaß verwendet wird | – |
| pg\$1similarity.dice\$1tokenizer | Legt den Tokenizer für das Dice-Ähnlichkeitsmaß fest. | – |
| pg\$1similarity.euclidean\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.euclidean\$1threshold | Legt den Schwellenwert fest, der vom euklidischen Ähnlichkeitsmaß verwendet wird. | – |
| pg\$1similarity.euclidean\$1tokenizer | Legt den Tokenizer für das euklidische Ähnlichkeitsmaß fest. | – |
| pg\$1similarity.hamming\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.hamming\$1threshold | Legt den Schwellenwert fest, der von der Block-Ähnlichkeitsmetrik verwendet wird. | – |
| pg\$1similarity.jaccard\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.jaccard\$1threshold | Legt den Schwellenwert fest, der vom Jaccard-Ähnlichkeitsmaß verwendet wird | – |
| pg\$1similarity.jaccard\$1tokenizer | Legt den Tokenizer für das Jaccard-Ähnlichkeitsmaß fest. | – |
| pg\$1similarity.jaro\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.jaro\$1threshold | Legt den Schwellenwert fest, der vom Jaro-Ähnlichkeitsmaß verwendet wird | – |
| pg\$1similarity.jarowinkler\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.jarowinkler\$1threshold | Legt den Schwellenwert fest, der vom Jaro-Winkler-Ähnlichkeitsmaß verwendet wird | – |
| pg\$1similarity.levenshtein\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.levenshtein\$1threshold | Legt den Schwellenwert fest, der vom Levenshtein-Ähnlichkeitsmaß verwendet wird | – |
| pg\$1similarity.matching\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.matching\$1threshold | Legt den Schwellenwert fest, der vom Matching-Koeffizient-Ähnlichkeitsmaß verwendet wird. | – |
| pg\$1similarity.matching\$1tokenizer | Legt den Tokenizer für das Matching-Koeffizient-Ähnlichkeitsmaß fest. | – |
| pg\$1similarity.mongeelkan\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.mongeelkan\$1threshold | Legt den Schwellenwert fest, der vom Monge-Elkan-Ähnlichkeitsmaß verwendet wird | – |
| pg\$1similarity.mongeelkan\$1tokenizer | Legt den Tokenizer für das Monge-Elkan-Ähnlichkeitsmaß fest. | – |
| pg\$1similarity.nw\$1gap\$1penalty | Legt den Lückenabzug fest, der vom Ähnlichkeitsmaß Needleman-Wunsch verwendet wird. | – |
| pg\$1similarity.nw\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.nw\$1threshold | Legt den Schwellenwert fest, der vom Ähnlichkeitsmaß Needleman-Wunsch verwendet wird. | – |
| pg\$1similarity.overlap\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.overlap\$1threshold | Legt den Schwellenwert fest, der vom Überschneidungskoeffizient-Ähnlichkeitsmaß verwendet wird. | – |
| pg\$1similarity.overlap\$1tokenizer | Legt den Tokenizer für das Überschneidungskoeffizient-Ähnlichkeitsmaß fest. | – |
| pg\$1similarity.qgram\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.qgram\$1threshold | Legt den Schwellenwert fest, der vom Q-Gram-Ähnlichkeitsmaß verwendet wird | – |
| pg\$1similarity.qgram\$1tokenizer | Legt den Tokenizer für die Q-Gram-Messung fest. | – |
| pg\$1similarity.swg\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.swg\$1threshold | Legt den Schwellenwert fest, der für das Ähnlichkeitsmaß verwendet wird. Smith-Waterman-Gotoh | – |
| pg\$1similarity.sw\$1is\$1normalized | Legt fest, ob der Ergebniswert normalisiert ist oder nicht. | – |
| pg\$1similarity.sw\$1threshold | Legt den Schwellenwert fest, der vom Smith-Waterman-Ähnlichkeitsmaß verwendet wird | – |
| pg\$1stat\$1statements.max | Legt die maximale Anzahl von Anweisungen fest, die von pg\$1stat\$1statements verfolgt werden. | – |
| pg\$1stat\$1statements.save | Speichert pg\$1stat\$1statements-Statistiken über Serverausfälle hinweg. | – |
| pg\$1stat\$1statements.track | Wählt aus, welche Anweisungen von pg\$1stat\$1statements verfolgt werden. | – |
| pg\$1stat\$1statements.track\$1planning | Wählt aus, ob die Planungsdauer von pg\$1stat\$1statements verfolgt wird. | – |
| pg\$1stat\$1statements.track\$1utility | Wählt aus, ob Dienstprogrammbefehle von pg\$1stat\$1statements verfolgt werden. | – |
| postgis.gdal\$1enabled\$1drivers | Aktiviert oder deaktiviert GDAL-Treiber, die mit PostGIS in Postgres 9.3.5 und höher verwendet werden. | ENABLE\$1ALL |
| quote\$1all\$1identifiers | Fügt beim Generieren von SQL-Fragmenten allen Bezeichnern Anführungszeichen hinzu. | – |
| random\$1page\$1cost | Legt die Schätzung des Planers für die Kosten einer nicht sequenziell abgerufenen Datenträgerseite fest. | – |
| rds.enable\$1memory\$1management | Verbessert die Funktionen zur Arbeitsspeicherverwaltung in Aurora-PostgreSQL-Versionen 12.17, 13.13, 14.10, 15.5 und höher, die Stabilitätsprobleme und Neustarts der Datenbank aufgrund von zu wenig freiem Arbeitsspeicher verhindern Weitere Informationen finden Sie unter [Verbesserte Arbeitsspeicherverwaltung in Aurora PostgreSQLEinschränkung](AuroraPostgreSQL.BestPractices.memory.management.md). | Wahr |
| rds.force\$1admin\$1logging\$1level | Siehe Protokollmeldungen für RDS-Admin-Benutzeraktionen in Kundendatenbanken. | – |
| rds.log\$1retention\$1period | Amazon RDS löscht PostgreSQL-Protokolle, die älter als N Minuten sind. | 4320 |
| rds.memory\$1allocation\$1guard | Verbessert die Funktionen zur Arbeitsspeicherverwaltung in Aurora-PostgreSQL-Versionen 11.21, 12.16, 13.12, 14.9, 15.4 und älter, die Stabilitätsprobleme und Neustarts der Datenbank aufgrund von zu wenig freiem Arbeitsspeicher verhindern Weitere Informationen finden Sie unter [Verbesserte Arbeitsspeicherverwaltung in Aurora PostgreSQLEinschränkung](AuroraPostgreSQL.BestPractices.memory.management.md). | Falsch |
| rds.pg\$1stat\$1ramdisk\$1size | Größe der Ramdisk-Statistiken in MB. Ein Wert ungleich Null richtet die Ramdisk ein. | 0 |
| rds.rds\$1superuser\$1reserved\$1connections | Legt die Anzahl der Verbindungs-Slots fest, die für rds\$1superusers reserviert sind. Dieser Parameter ist nur für Version 15 und niedriger verfügbar. Weitere Informationen finden Sie in der PostgreSQL-Dokumentation unter [Reservierte Verbindungen](https://www.postgresql.org/docs/current/runtime-config-connection.html#GUC-RESERVED-CONNECTIONS). | 2 |
| rds.superuser\$1variables | Liste der reinen Superuser-Variablen, für die wir die Änderungsanweisungen von rds\$1superuser erhöhen. | session\$1replication\$1role |
| remove\$1temp\$1files\$1after\$1crash | Entfernt temporäre Dateien nach dem Backend-Absturz. | 0 |
| restart\$1after\$1crash | Initialisiert den Server nach dem Backend-Absturz neu. | – |
| row\$1security | Aktiviert Zeilensicherheit. | – |
| search\$1path | Legt die Schemasuchreihenfolge für Namen fest, die nicht schemaqualifiziert sind. | – |
| seq\$1page\$1cost | Legt die Schätzung des Planers für die Kosten einer sequenziell abgerufenen Datenträgerseite fest. | – |
| session\$1replication\$1role | Legt das Sitzungsverhalten für Auslöser und Neuschreibungsregeln fest. | – |
| shared\$1buffers | (8 kB) Legt die maximale Anzahl freigegebener Arbeitsspeicherpuffer fest, die vom Server verwendet werden. | SUMME (DBInstanceClassMemory/12038, -50003) |
| shared\$1preload\$1libraries | Listet freigegebene Bibliotheken auf, die in den Server vorgeladen werden. | pg\$1stat\$1statements |
| ssl\$1ca\$1file | Speicherort der SSL-Server-Zertifizierungsstellendatei. | rdsdbdata/rds-metadata/ca/-cert.pem |
| ssl\$1cert\$1file | Speicherort der SSL-Serverzertifikatdatei. | /rdsdbdata/rds-metadata/server-cert.pem |
| ssl\$1crl\$1dir | Speicherort des Verzeichnisses der SSL-Zertifikatsperrliste. | /rdsdbdata/rds-metadata/ssl\$1crl\$1dir/ |
| ssl\$1key\$1file | Speicherort der privaten Schlüsseldatei des SSL-Servers | /rdsdbdata/rds-metadata/server-key.pem |
| standard\$1conforming\$1strings | Veranlasst Zeichenfolgen „...“, Backslashes als Zeichen zu behandeln. | – |
| statement\$1timeout | (ms) Legt die maximal zulässige Dauer von Anweisungen fest. | – |
| stats\$1temp\$1directory | Schreibt temporäre Statistikdateien in das angegebene Verzeichnis. | /rdsdbdata/db/pg\$1stat\$1tmp |
| superuser\$1reserved\$1connections | Legt die Anzahl der Verbindungs-Slots fest, die für Superusers reserviert sind. | 3 |
| synchronize\$1seqscans | Ermöglicht synchronisierte sequenzielle Prüfungen. | – |
| tcp\$1keepalives\$1count | Maximale Anzahl von TCP-Keepalive-Neuübertragungen. | – |
| tcp\$1keepalives\$1idle | (s) Zeit zwischen der Ausgabe von TCP-Keepalives. | – |
| tcp\$1keepalives\$1interval | (s) Zeit zwischen der Ausgabe von TCP-Keepalive-Neuübertragungen. | – |
| temp\$1buffers | (8 kB) Legt die maximale Anzahl der temporären Puffer fest, die von den einzelnen Sitzungen verwendet werden. | – |
| temp\$1file\$1limit | Schränkt den Gesamtspeicherplatz in Kilobyte ein, den ein bestimmter PostgreSQL-Prozess für temporäre Dateien verwenden kann, ausschließlich von Speicherplatz, der für explizite temporäre Tabellen verwendet wird | -1 |
| temp\$1tablespaces | Legt die Tabellenräume fest, die für temporäre Tabellen und Sortierdateien verwendet werden sollen. | – |
| track\$1activities | Sammelt Informationen zu Befehlen, die ausgeführt werden. | – |
| track\$1activity\$1query\$1size | Legt die für pg\$1stat\$1activity.current\$1query reservierte Größe in Bytes fest. | 4096 |
| track\$1counts | Sammelt Statistiken zur Datenbankaktivität. | – |
| track\$1functions | Sammelt Statistiken auf Funktionsebene zur Datenbankaktivität. | pl |
| track\$1io\$1timing | Erfasst Zeitpunktstatistiken zur Datenbank-E/A-Aktivität. | 1 |
| transform\$1–\$1equals | Behandelt expr=– als expr IS –. | – |
| update\$1process\$1title | Aktualisiert den Titel des Vorgangs, um den aktiven SQL-Befehl anzuzeigen. | – |
| wal\$1receiver\$1status\$1interval | (s) Legt das maximale Intervall zwischen den Statusberichten des WAL-Receivers auf den primären Wert fest. | – |
| work\$1mem | (kB) Legt den maximalen Arbeitsspeicher fest, der für Abfrage-Workspaces verwendet werden darf. | – |
| xmlbinary | Legt die Kodierung von Binärwerten in XML fest. | – |
| xmloption | Legt fest, ob XML-Daten in impliziten Parsing- und Serialisierungsoperationen als Dokumente oder Inhaltsfragmente betrachtet werden sollen. | – |
# Amazon-Aurora-PostgreSQL-Warteereignisse
Im Folgenden sind gängige Warteereignisse für Aurora PostgreSQL aufgeführt. Weitere Informationen über Warteereignisse und die Optimierung Ihres Aurora-PostgreSQL-DB-Clusters finden Sie unter [Optimierung mit Warteereignissen für Aurora PostgreSQL](AuroraPostgreSQL.Tuning.md).
**Aktivität: ArchiverMain**
Der Archivierungsprozess wartet auf Aktivität.
**Aktivität: AutoVacuumMain**
Der Autovacuum-Launcher-Prozess wartet auf Aktivität.
**Aktivität: BgWriterHibernate**
Der Hintergrundschreibprozess befindet sich im Ruhezustand, während er auf Aktivität wartet.
**Aktivität: BgWriterMain**
Der Hintergrundschreibprozess wartet auf Aktivität.
**Aktivität: CheckpointerMain**
Der Checkpointer-Prozess wartet auf Aktivität.
**Aktivität: LogicalApplyMain**
Der Prozess zum Anwenden der logischen Replikation wartet auf Aktivität.
**Aktivität: LogicalLauncherMain**
Der Startprozess für die logische Replikation wartet auf Aktivität.
**Aktivität: PgStatMain**
Der Statistikkollektorprozess wartet auf Aktivität.
**Aktivität: RecoveryWalAll**
Ein Prozess wartet bei der Wiederherstellung auf das Write-Ahead-Log (WAL) von einem Stream.
**Aktivität: RecoveryWalStream**
Der Startup-Vorgang wartet auf das Eintreffen des Write-Ahead-Log (WAL) während der Streaming-Wiederherstellung.
**Aktivität: SysLoggerMain**
Der Syslogger-Prozess wartet auf Aktivität.
**Aktivität: WalReceiverMain**
Der WAL-Receiver-Prozess wartet auf Aktivität.
**Aktivität: WalSenderMain**
Der WAL-Senderprozess (Write-Ahead-Log) wartet auf Aktivität.
**Aktivität: WalWriterMain**
Der Write-Ahead-Log (WAL)-Writerprozess wartet auf Aktivität.
**BufferPin:BufferPin**
Ein Prozess wartet darauf, einen exklusiven Pin an einem Puffer zu erhalten.
**Kunde: GSSOpen Server**
Ein Prozess wartet darauf, Daten vom Client zu lesen, während er eine GSSAPI-Sitzung (Generic Security Service Application Program Interface) aufbaut.
**Kunde: ClientRead**
Ein Backend-Prozess wartet darauf, Daten von einem PostgreSQL-Client zu empfangen. Weitere Informationen finden Sie unter [Kunde: ClientRead](apg-waits.clientread.md).
**Kunde: ClientWrite**
Ein Backend-Prozess wartet darauf, weitere Daten an einen PostgreSQL-Client zu senden. Weitere Informationen finden Sie unter [Kunde: ClientWrite](apg-waits.clientwrite.md).
**Kunde: Lib PQWal ReceiverConnect**
Ein Prozess wartet im WAL-Receiver darauf, eine Verbindung zum Remote-Server herzustellen.
**Kunde: Lib PQWal ReceiverReceive**
Ein Prozess wartet im Write-Ahead-Log (WAL)-Receiver darauf, Daten vom Remote-Server zu empfangen.
**Kunde: Server SSLOpen**
Ein Prozess wartet auf Secure Sockets Layer (SSL), während er versucht, eine Verbindung herzustellen.
**Kunde: WalReceiverWaitStart**
Ein Prozess wartet darauf, dass der Startup-Prozess die Anfangsdaten für die Streaming-Replikation sendet.
**Kunde: WalSenderWaitFor WAL**
Ein Prozess wartet darauf, dass das Write-Ahead-Log (WAL) im WAL-Senderprozess geleert wird.
**Kunde: WalSenderWriteData**
Ein Prozess wartet auf eine Aktivität, wenn er Antworten vom Write-Ahead-Log (WAL)-Receiver im WAL-Senderprozess verarbeitet.
**CPU**
Ein Backend-Prozess ist in der CPU aktiv oder wartet auf diese. Weitere Informationen finden Sie unter [CPU](apg-waits.cpu.md).
**Extension:extension**
Ein Backend-Prozess wartet auf eine Bedingung, die von einer Erweiterung oder einem Modul definiert wird.
**IO: AuroraEnhancedLogical WALRead**
Ein Backend-Prozess ruft Protokolldatensätze vom Change Data Capture (CDC)-Volume ab.
**IO: AuroraOptimizedReadsCacheRead**
Ein Prozess wartet auf einen Lesevorgang aus dem mehrstufigen Cache für optimierte Lesevorgänge, da die Seite nicht im gemeinsam genutzten Speicher verfügbar ist.
**IO: AuroraOptimizedReads CacheSegmentKürzen**
Ein Prozess wartet darauf, dass eine Segmentdatei des gestuften Caches für optimierte Lesevorgänge gekürzt wird.
**IO: AuroraOptimizedReadsCacheWrite**
Der Hintergrund-Writer-Prozess wartet darauf, in den mehrstufigen Cache für optimierte Lesevorgänge zu schreiben.
**IO: AuroraStorageLogAllocate**
Eine Sitzung weist Metadaten zu und bereitet einen Schreibvorgang für das Transaktionsprotokoll vor.
**IO: BufFileRead**
Wenn Vorgänge mehr Speicher benötigen, als durch die Parameter des Arbeitsspeichers definiert ist, erstellt die Engine temporäre Dateien auf der Festplatte. Dieses Warteereignis tritt auf, wenn Vorgänge aus den temporären Dateien gelesen werden. Weitere Informationen finden Sie unter [IO: BufFileRead und IO: BufFileWrite](apg-waits.iobuffile.md).
**IO: BufFileWrite**
Wenn Vorgänge mehr Speicher benötigen, als durch die Parameter des Arbeitsspeichers definiert ist, erstellt die Engine temporäre Dateien auf der Festplatte. Dieses Warteereignis tritt auf, wenn Vorgänge in die temporären Dateien schreiben. Weitere Informationen finden Sie unter [IO: BufFileRead und IO: BufFileWrite](apg-waits.iobuffile.md).
**IO: ControlFileRead**
Ein Prozess wartet auf das Lesen der `pg_control`-Datei.
**IO: ControlFileSync**
Ein Prozess wartet darauf, dass die `pg_control`-Datei den dauerhaften Speicher erreicht.
**IO: ControlFileSyncUpdate**
Ein Prozess wartet auf eine Aktualisierung der `pg_control`-Datei, um einen dauerhaften Speicher zu erreichen.
**IO: ControlFileWrite**
Ein Prozess wartet auf einen Schreibvorgang in die `pg_control`-Datei.
**IO: ControlFileWriteUpdate**
Ein Prozess wartet auf einen Schreibvorgang, um die `pg_control`-Datei zu aktualisieren.
**IO: CopyFileRead**
Ein Prozess wartet auf das Lesen während eines Dateikopiervorgangs.
**IO: CopyFileWrite**
Ein Prozess wartet während einer Dateikopieroperation auf einen Schreibvorgang.
**IO: DataFileExtend**
Ein Prozess wartet darauf, dass eine Relationsdatendatei erweitert wird.
**IO: DataFileFlush**
Ein Prozess wartet darauf, dass eine Relationsdatendatei einen dauerhaften Speicher erreicht.
**IO: DataFileImmediateSync**
Ein Prozess wartet auf eine sofortige Synchronisierung einer Relationsdatendatei mit einem dauerhaften Speicher.
**IO: DataFilePrefetch**
Ein Prozess wartet auf einen asynchronen Vorabruf aus einer Relationsdatendatei.
**IO: DataFileSync**
Ein Prozess wartet darauf, dass Änderungen an einer Relationsdatendatei einen dauerhaften Speicher erreichen.
**IO: DataFileRead**
Ein Backend-Prozess hat versucht, eine Seite in den freigegebenen Puffern zu finden, hat sie jedoch nicht gefunden und sie daher aus dem Speicher gelesen. Weitere Informationen finden Sie unter [IO: DataFileRead](apg-waits.iodatafileread.md).
**IO: DataFileTruncate**
Ein Prozess wartet darauf, dass eine Relationsdatendatei abgeschnitten wird.
**IO: DataFileWrite**
Ein Prozess wartet auf einen Schreibvorgang in eine Relationsdatendatei.
**IO: DSMFill ZeroWrite**
Ein Prozess wartet darauf, null Bytes in eine dynamische Shared Memory-Backing-Datei zu schreiben.
**IO: LockFileAddToDataDirRead**
Ein Prozess wartet auf das Lesen, während er der Datenverzeichnis-Sperrdatei eine Zeile hinzufügt.
**IO: LockFileAddToDataDirSync**
Ein Prozess wartet darauf, dass Daten einen dauerhaften Speicher erreichen, während er der Datenverzeichnis-Sperrdatei eine Zeile hinzufügt.
**IO: LockFileAddToDataDirWrite**
Ein Prozess wartet auf einen Schreibvorgang, während er der Datenverzeichnis-Sperrdatei eine Zeile hinzufügt.
**IO: LockFileCreateRead**
Ein Prozess wartet auf das Lesen, während er die Datenverzeichnis-Sperrdatei erstellt.
**IO: LockFileCreateSync**
Ein Prozess wartet darauf, dass Daten einen dauerhaften Speicher erreichen, während er die Datenverzeichnis-Sperrdatei erstellt.
**IO: LockFileCreateWrite**
Ein Prozess wartet auf einen Schreibvorgang, während er die Datenverzeichnis-Sperrdatei erstellt.
**IO: LockFileReCheckDataDirRead**
Ein Prozess wartet während der erneuten Überprüfung der Datenverzeichnis-Sperrdatei auf das Lesen.
**IO: LogicalRewriteCheckpointSync**
Ein Prozess wartet darauf, dass logische Rewrite-Mappings während eines Checkpoints dauerhaften Speicher erreichen.
**IO: LogicalRewriteMappingSync**
Ein Prozess wartet darauf, dass Mapping-Daten während eines logischen Neuschreibens einen dauerhaften Speicher erreichen.
**IO: LogicalRewriteMappingWrite**
Ein Prozess wartet während eines logischen Rewrite auf ein Schreiben von Mapping-Daten.
**IO: LogicalRewriteSync**
Ein Prozess wartet auf logische Rewrite-Zuordnungen, um dauerhaften Speicher zu erreichen.
**IO: LogicalRewriteTruncate**
Ein Prozess wartet auf das Abschneiden von Mapping-Daten während eines logischen Neuschreibens.
**IO: LogicalRewriteWrite**
Ein Prozess wartet auf einen Schreibvorgang von logischen Rewrite-Mappings.
**IO: RelationMapRead**
Ein Prozess wartet auf das Lesen der Relation Map-Datei.
**IO: RelationMapSync**
Ein Prozess wartet darauf, dass die Relationszuordnungsdatei einen dauerhaften Speicher erreicht.
**IO: RelationMapWrite**
Ein Prozess wartet auf einen Schreibvorgang in die Relation Map-Datei.
**IO: ReorderBufferRead**
Ein Prozess wartet während der Neuordnungs-Pufferverwaltung auf das Lesen.
**IO: ReorderBufferWrite**
Ein Prozess wartet während der Neuordnungs-Pufferverwaltung auf einen Schreibvorgang.
**IO: ReorderLogicalMappingRead**
Ein Prozess wartet während der Neuordnungspufferverwaltung auf das Lesen einer logischen Abbildung.
**IO: ReplicationSlotRead**
Ein Prozess wartet auf das Lesen aus einer Replikations-Slot-Steuerungsdatei.
**IO: ReplicationSlotRestoreSync**
Ein Prozess wartet darauf, dass eine Replikations-Slot-Steuerungsdatei einen dauerhaften Speicher erreicht, während sie im Arbeitsspeicher wiederhergestellt wird.
**IO: ReplicationSlotSync**
Ein Prozess wartet darauf, dass eine Replikations-Slot-Steuerdatei einen dauerhaften Speicher erreicht.
**IO: ReplicationSlotWrite**
Ein Prozess wartet auf einen Schreibvorgang in eine Replikations-Slot-Steuerdatei.
**IO: SLRUFlush Synchronisieren**
Ein Prozess wartet darauf, dass einfache, selten verwendete Daten (SLRU-Daten) während eines Prüfpunkts oder beim Herunterfahren der Datenbank in einem dauerhaften Speicher abgelegt werden.
**IO: SLRURead**
Ein Prozess wartet auf das Lesen einer einfachen, selten verwendeten Seite (SLRU-Seite).
**IO: SLRUSync**
Ein Prozess wartet darauf, dass einfache, selten verwendete Daten (SLRU-Daten) nach einem Seitenschreibvorgang in einem dauerhaften Speicher abgelegt werden.
**IO: SLRUWrite**
Ein Prozess wartet auf den Schreibvorgang einer einfachen, selten verwendeten Seite (SLRU-Seite).
**IO: SnapbuildRead**
Ein Prozess wartet auf das Lesen eines serialisierten historischen Katalog-Snapshots.
**IO: SnapbuildSync**
Ein Prozess wartet darauf, dass ein serialisierter historischer Katalog-Snapshot einen dauerhaften Speicher erreicht.
**IO: SnapbuildWrite**
Ein Prozess wartet auf das Schreiben eines serialisierten historischen Katalog-Snapshots.
**IO: TimelineHistoryFileSync**
Ein Prozess wartet darauf, dass eine Zeitachsenverlaufsdatei, die über die Streaming-Replikation empfangen wurde, im dauerhaften Speicher abgelegt wird.
**IO: TimelineHistoryFileWrite**
Ein Prozess wartet auf das Schreiben einer Zeitachsenverlaufsdatei, die über die Streaming-Replikation empfangen wurde.
**IO: TimelineHistoryRead**
Ein Prozess wartet auf das Lesen einer Zeitachsenverlaufsdatei.
**IO: TimelineHistorySync**
Ein Prozess wartet darauf, dass eine neu erstellte Zeitachsenverlaufsdatei einen dauerhaften Speicher erreicht.
**IO: TimelineHistoryWrite**
Ein Prozess wartet auf das Schreiben einer neu erstellten Zeitachsenverlaufsdatei.
**IO: TwophaseFileRead**
Ein Prozess wartet auf das Lesen einer Zweiphasen-Statusdatei.
**IO: TwophaseFileSync**
Ein Prozess wartet darauf, dass eine zweiphasige Zustandsdatei einen dauerhaften Speicher erreicht.
**IO: TwophaseFileWrite**
Ein Prozess wartet auf das Schreiben einer Zweiphasen-Zustandsdatei.
**IO: WALBootstrap Synchronisieren**
Ein Prozess wartet darauf, dass das Write-Ahead-Log (WAL) während des Bootstrapping im dauerhaften Speicher abgelegt wird.
**IO: WALBootstrap Schreiben**
Ein Prozess wartet während des Bootstrapping auf das Schreiben einer WAL-Seite.
**IO: WALCopy Lesen**
Ein Prozess wartet auf das Lesen, wenn ein neues Write-Ahead-Log (WAL)-Segment erstellt wird, indem ein vorhandenes kopiert wird.
**IO: WALCopy Synchronisieren**
Ein Prozess wartet auf ein neues WAL-Segment (Write-Ahead-Log), das durch Kopieren eines vorhandenen Segments erstellt wurde, um dauerhaften Speicher zu erreichen.
**IO: WALCopy Schreiben**
Ein Prozess wartet auf einen Schreibvorgang, wenn er ein neues WAL-Segment (Write-Ahead-Log) erstellt, indem er ein vorhandenes kopiert.
**IO: WALInit Synchronisieren**
Ein Prozess wartet darauf, dass eine neu initialisierte Write-Ahead-Log-Datei (WAL) im dauerhaften Speicher abgelegt wird.
**IO: WALInit Schreiben**
Ein Prozess wartet auf einen Schreibvorgang, während er eine neue Write-Ahead-Protokolldatei (WAL) initialisiert.
**IO: WALRead**
Ein Prozess wartet auf das Lesen aus einer Write-Ahead-Protokolldatei (WAL).
**IO: WALSender TimelineHistoryRead**
Ein Prozess wartet während eines WAL-Sender-Zeitachsenbefehls auf das Lesen aus einer Zeitachsenverlaufsdatei.
**IO: WALSync**
Ein Prozess wartet darauf, dass eine Write-Ahead-Protokolldatei (WAL) einen dauerhaften Speicher erreicht.
**IO: WALSync MethodAssign**
Ein Prozess wartet darauf, dass Daten einen dauerhaften Speicher erreichen, während er eine neue WAL-Synchronisierungsmethode (Write-Ahead-Log) zuweist.
**IO: WALWrite**
Ein Prozess wartet auf einen Schreibvorgang in eine Write-Ahead-Protokolldatei (WAL).
**IO: XactSync**
Ein Backend-Prozess wartet darauf, dass das Aurora-Speichersubsystem den Commit einer regulären Transaktion oder den Commit oder das Rollback einer vorbereiteten Transaktion bestätigt. Weitere Informationen finden Sie unter [IO:XactSync](apg-waits.xactsync.md).
**IPC: AuroraLogicalSchemaUpdate**
Zwei Backend-Prozesse versuchen, denselben Eintrag in den Schema-Cache einzufügen. Ein Prozess wird fortgesetzt, während der andere auf seinen Abschluss wartet.
**IPC: AuroraOptimizedReadsCacheWriteStop**
Ein Prozess wartet darauf, dass der Hintergrundschreiber das Schreiben in den gestuften Cache für optimierte Lesevorgänge beendet.
**IPC: BackupWaitWalArchive**
Ein Prozess wartet auf Write-Ahead-Log-Dateien (WAL), die für eine erfolgreiche Archivierung einer Sicherung erforderlich sind.
**IPC: BgWorkerShutdown**
Ein Prozess wartet darauf, dass ein Arbeitsprozess im Hintergrund heruntergefahren wird.
**IPC: BgWorkerStartup**
Ein Prozess wartet darauf, dass ein Hintergrund-Worker gestartet wird.
**IPC: BtreePage**
Ein Prozess wartet darauf, dass die Seitennummer, die zum Fortsetzen einer parallelen B-Baum-Abtastung benötigt wird, verfügbar wird.
**IPC: CheckpointDone**
Ein Prozess wartet darauf, dass ein Checkpoint abgeschlossen wird.
**IPC: CheckpointStart**
Ein Prozess wartet auf den Start eines Checkpoints.
**IPC: ClogGroupUpdate**
Ein Prozess wartet darauf, dass der Gruppenleiter den Transaktionsstatus am Ende einer Transaktion aktualisiert.
**IPC: DamRecordTxAck**
Ein Backend-Prozess hat ein Ereignis für Datenbank-Aktivitätsströme generiert und wartet darauf, dass das Ereignis dauerhaft wird. Weitere Informationen finden Sie unter [IPC:DamRecordTxAck](apg-waits.ipcdamrecordtxac.md).
**IPC: ExecuteGather**
Ein Prozess wartet auf Aktivitäten von einem untergeordneten Prozess, während er einen Gather-Plan-Knoten ausführt.
**IPC: Hash/Batch/Allocating**
Ein Prozess wartet darauf, dass ein gewählter paralleler Hash-Teilnehmer eine Hash-Tabelle zuweist.
**IPC: Hash/Batch/Electing**
Ein Prozess wählt einen parallelen Hash-Teilnehmer aus, um eine Hash-Tabelle zuzuweisen.
**IPC: Hash/Batch/Loading**
Ein Prozess wartet darauf, dass andere parallele Hash-Teilnehmer das Laden einer Hash-Tabelle abgeschlossen haben.
**IPC: Hash/Build/Allocating**
Ein Prozess wartet darauf, dass ein gewählter paralleler Hash-Teilnehmer die anfängliche Hash-Tabelle zuweist.
**IPC: Hash/Build/Electing**
Ein Prozess wählt einen parallelen Hash-Teilnehmer aus, um die anfängliche Hash-Tabelle zuzuweisen.
**IPC: Hash/Build/HashingInner**
Ein Prozess wartet darauf, dass andere parallele Hash-Teilnehmer das Hashing der inneren Beziehung abgeschlossen haben.
**IPC: Hash/Build/HashingOuter**
Ein Prozess wartet darauf, dass andere parallele Hash-Teilnehmer die Partitionierung der äußeren Beziehung abschließen.
**IPC: Hash/GrowBatches/Allocating**
Ein Prozess wartet darauf, dass ein gewählter paralleler Hash-Teilnehmer weitere Batches zuweist.
**IPC: Hash/GrowBatches/Deciding**
Ein Prozess wählt einen parallelen Hash-Teilnehmer aus, um über zukünftiges Batch-Wachstum zu entscheiden.
**IPC: Hash/GrowBatches/Electing**
Ein Prozess wählt einen parallelen Hash-Teilnehmer aus, um mehr Batches zuzuweisen.
**IPC: Hash/GrowBatches/Finishing**
Ein Prozess wartet darauf, dass ein gewählter paralleler Hash-Teilnehmer über zukünftiges Batch-Wachstum entscheidet.
**IPC: Hash/GrowBatches/Repartitioning**
Ein Prozess wartet darauf, dass andere parallele Hash-Teilnehmer die Neupartitionierung abgeschlossen haben.
**IPC: Hash/GrowBuckets/Allocating**
Ein Prozess wartet darauf, dass ein gewählter paralleler Hash-Teilnehmer die Zuweisung weiterer Buckets abgeschlossen hat.
**IPC: Hash/GrowBuckets/Electing**
Ein Prozess wählt einen parallelen Hash-Teilnehmer aus, um mehr Buckets zuzuweisen.
**IPC: Hash/GrowBuckets/Reinserting**
Ein Prozess wartet darauf, dass andere parallele Hash-Teilnehmer das Einfügen von Tupeln in neue Buckets abgeschlossen haben.
**IPC: HashBatchAllocate**
Ein Prozess wartet darauf, dass ein gewählter paralleler Hash-Teilnehmer eine Hash-Tabelle zuweist.
**IPC: HashBatchElect**
Ein Prozess wartet darauf, einen parallelen Hash-Teilnehmer auszuwählen, um eine Hash-Tabelle zuzuweisen.
**IPC: HashBatchLoad**
Ein Prozess wartet darauf, dass andere parallele Hash-Teilnehmer das Laden einer Hash-Tabelle abgeschlossen haben.
**IPC: HashBuildAllocate**
Ein Prozess wartet darauf, dass ein gewählter paralleler Hash-Teilnehmer die anfängliche Hash-Tabelle zuweist.
**IPC: HashBuildElect**
Ein Prozess wartet darauf, einen parallelen Hash-Teilnehmer auszuwählen, um die anfängliche Hash-Tabelle zuzuweisen.
**IPC: HashBuildHashInner**
Ein Prozess wartet darauf, dass andere parallele Hash-Teilnehmer das Hashing der inneren Beziehung abgeschlossen haben.
**IPC: 'HashBuildHashOuter**
Ein Prozess wartet darauf, dass andere parallele Hash-Teilnehmer die Partitionierung der äußeren Beziehung abschließen.
**IPC: HashGrowBatchesAllocate**
Ein Prozess wartet darauf, dass ein gewählter paralleler Hash-Teilnehmer weitere Batches zuweist.
**IPC: 'HashGrowBatchesDecide**
Ein Prozess wartet darauf, einen parallelen Hash-Teilnehmer auszuwählen, um über das zukünftige Batch-Wachstum zu entscheiden.
**IPC: HashGrowBatchesElect**
Ein Prozess wartet darauf, einen parallelen Hash-Teilnehmer auszuwählen, um weitere Batches zuzuweisen.
**IPC: HashGrowBatchesFinish**
Ein Prozess wartet darauf, dass ein gewählter paralleler Hash-Teilnehmer über zukünftiges Batch-Wachstum entscheidet.
**IPC: HashGrowBatchesRepartition**
Ein Prozess wartet darauf, dass andere parallele Hash-Teilnehmer die Neupartitionierung beenden.
**IPC: HashGrowBucketsAllocate**
Ein Prozess wartet darauf, dass ein gewählter paralleler Hash-Teilnehmer die Zuweisung weiterer Buckets abgeschlossen hat.
**IPC: HashGrowBucketsElect**
Ein Prozess wartet darauf, einen parallelen Hash-Teilnehmer auszuwählen, um weitere Buckets zuzuweisen.
**IPC: HashGrowBucketsReinsert**
Ein Prozess wartet darauf, dass andere parallele Hash-Teilnehmer das Einfügen von Tupeln in neue Buckets abgeschlossen haben.
**IPC: LogicalSyncData**
Ein Prozess wartet darauf, dass ein Remote-Server für die logische Replikation Daten für die anfängliche Tabellensynchronisierung sendet.
**IPC: LogicalSyncStateChange**
Ein Prozess wartet darauf, dass ein logischer Replikations-Remote-Server seinen Status ändert.
**IPC: MessageQueueInternal**
Ein Prozess wartet darauf, dass ein anderer Prozess an eine gemeinsam genutzte Nachrichtenwarteschlange angehängt wird.
**IPC: MessageQueuePutMessage**
Ein Prozess wartet darauf, eine Protokollnachricht in eine gemeinsam genutzte Nachrichtenwarteschlange zu schreiben.
**IPC: MessageQueueReceive**
Ein Prozess wartet darauf, Bytes aus einer gemeinsam genutzten Nachrichtenwarteschlange zu empfangen.
**IPC: MessageQueueSend**
Ein Prozess wartet darauf, Bytes an eine gemeinsam genutzte Nachrichtenwarteschlange zu senden.
**IPC: ParallelBitmapScan**
Ein Prozess wartet darauf, dass ein paralleler Bitmap-Scan initialisiert wird.
**IPC: ParallelCreateIndexScan**
Ein Prozess wartet darauf, dass parallele CREATE INDEX-Arbeitsprozesse einen Heap-Scan abschließen.
**IPC: ParallelFinish**
Ein Prozess wartet darauf, dass parallele Arbeitsprozesse die Berechnung abgeschlossen haben.
**IPC: ProcArrayGroupUpdate**
Ein Prozess wartet darauf, dass der Gruppenleiter die Transaktions-ID am Transaktionsende löscht.
**IPC: ProcSignalBarrier**
Ein Prozess wartet darauf, dass ein Barriere-Ereignis von allen Backends verarbeitet wird.
**IPC:Promote**
Ein Prozess wartet auf die Standby-Heraufstufung.
**IPC: RecoveryConflictSnapshot**
Ein Prozess wartet auf die Lösung des Wiederherstellungskonflikts für eine Vakuumbereinigung.
**IPC: RecoveryConflictTablespace**
Ein Prozess wartet auf die Lösung eines Wiederherstellungskonflikts, um einen Tablespace zu löschen.
**IPC: RecoveryPause**
Ein Prozess wartet darauf, dass die Wiederherstellung fortgesetzt wird.
**IPC: ReplicationOriginDrop**
Ein Prozess wartet darauf, dass ein Replikationsursprung inaktiv wird, damit er gelöscht werden kann.
**IPC: ReplicationSlotDrop**
Ein Prozess wartet darauf, dass ein Replikations-Slot inaktiv wird, damit er gelöscht werden kann.
**IPC: SafeSnapshot**
Ein Prozess wartet darauf, einen gültigen Snapshot für eine READ ONLY DEFERRABLE-Transaktion abzurufen.
**IPC: SyncRep**
Ein Prozess wartet während der synchronen Replikation auf die Bestätigung eines Remote-Servers.
**IPC: XactGroupUpdate**
Ein Prozess wartet darauf, dass der Gruppenleiter den Transaktionsstatus am Transaktionsende aktualisiert.
**Lock:advisory**
Ein Backend-Prozess hat eine Advisory-Sperre angefordert und wartet darauf. Weitere Informationen finden Sie unter [Lock:advisory](apg-waits.lockadvisory.md).
**Lock:extend**
Ein Backend-Prozess wartet darauf, dass eine Sperre freigegeben wird, damit er eine Relation erweitern kann. Diese Sperre wird benötigt, da jeweils nur ein Backend-Prozess eine Relation erweitern kann. Weitere Informationen finden Sie unter [Lock:extend](apg-waits.lockextend.md).
**Lock:frozenid**
Ein Prozess wartet darauf, `pg_database.datfrozenxid` und `pg_database.datminmxid` zu aktualisieren.
**Lock:object**
Ein Prozess wartet darauf, eine Sperre für ein Objekt einer nichtrelationalen Datenbank zu erhalten.
**Lock:page**
Ein Prozess wartet darauf, eine Sperre für eine Seite einer Relation zu erhalten.
**Lock:Relation**
Ein Backend-Prozess wartet darauf, eine Sperre für eine Relation zu erlangen, die durch eine andere Transaktion gesperrt ist. Weitere Informationen finden Sie unter [Lock:Relation](apg-waits.lockrelation.md).
**Lock:spectoken**
Ein Prozess wartet darauf, eine spekulative Einfügesperre zu erhalten.
**Lock:speculative token**
Ein Prozess wartet darauf, eine spekulative Einfügesperre zu erlangen.
**Lock:transactionid**
Eine Transaktion wartet auf eine Sperre auf Zeilenebene. Weitere Informationen finden Sie unter [Lock:transactionid](apg-waits.locktransactionid.md).
**Lock:tuple**
Ein Backend-Prozess wartet darauf, eine Sperre für ein Tupel zu erlangen, während ein anderer Backend-Prozess eine widersprüchliche Sperre für dasselbe Tupel hält. Weitere Informationen finden Sie unter [Lock:tuple](apg-waits.locktuple.md).
**Lock:userlock**
Ein Prozess wartet darauf, eine Benutzersperre zu erhalten.
**Lock:virtualxid**
Ein Prozess wartet darauf, eine virtuelle Transaktions-ID-Sperre zu erhalten.
**LWLock:AddinShmemInit**
Ein Prozess wartet darauf, die Speicherplatzzuweisung einer Erweiterung im gemeinsam genutzten Speicher zu verwalten.
**LWLock:AddinShmemInitLock**
Ein Prozess wartet darauf, die Speicherplatzzuweisung im gemeinsam genutzten Speicher zu verwalten.
**LWLockIPC: ----sep----:asynchron**
Ein Prozess wartet I/O auf einen asynchronen Puffer (Notify).
**LWLock:AsyncCtlLock**
Ein Prozess wartet darauf, einen freigegebenen Benachrichtigungsstatus zu lesen oder zu aktualisieren.
**LWLock:AsyncQueueLock**
Ein Prozess wartet darauf, Benachrichtigungen zu lesen oder zu aktualisieren.
**LWLock:AuroraOptimizedReadsCacheMapping**
Ein Prozess wartet darauf, einen Datenblock mit einer Seite im mehrstufigen Cache für optimierte Lesevorgänge zu verknüpfen.
**LWLock:AutoFile**
Ein Prozess wartet darauf, die Datei `postgresql.auto.conf` zu aktualisieren.
**LWLock:AutoFileLock**
Ein Prozess wartet darauf, die Datei `postgresql.auto.conf` zu aktualisieren.
**LWLockEin Prozess wartet auf einen asynchronen Puffer (Notify). ----sep----:AutoVacuum**
Ein Prozess wartet darauf, den aktuellen Status der Autovacuum-Arbeitsprozesse zu lesen oder zu aktualisieren.
**LWLock:AutovacuumLock**
Ein Autovacuum-Worker oder ein Startprogramm wartet darauf, den aktuellen Status der Autovacuum-Worker zu aktualisieren oder zu lesen.
**LWLock:AutovacuumSchedule**
Ein Prozess wartet, um sicherzustellen, dass eine für den Autovaccuum-Prozess ausgewählte Tabelle noch bereinigt werden muss.
**LWLock:AutovacuumScheduleLock**
Ein Prozess wartet, um sicherzustellen, dass eine für den Autovakcuum-Prozess ausgewählte Tabelle noch bereinigt werden muss.
**LWLock:BackendRandomLock**
Ein Prozess wartet darauf, eine Zufallszahl zu generieren.
**LWLock:BackgroundWorker**
Ein Prozess wartet darauf, den Hintergrund-Worker-Status zu lesen oder zu aktualisieren.
**LWLock:BackgroundWorkerLock**
Ein Prozess wartet darauf, den Hintergrund-Worker-Status zu lesen oder zu aktualisieren.
**LWLock:BtreeVacuum**
Ein Prozess wartet darauf, vacuumbezogene Informationen für einen B-Baum-Index zu lesen oder zu aktualisieren.
**LWLock:BtreeVacuumLock**
Ein Prozess wartet darauf, vacuumbezogene Informationen für einen B-Baum-Index zu lesen oder zu aktualisieren.
**LWLock:Autovacuum----sep----:buffer\$1content**
Ein Backend-Prozess wartet darauf, eine einfache Sperre für den Inhalt eines gemeinsam genutzten Speicherpuffers zu erlangen. Weitere Informationen finden Sie unter [LWLock:buffer\$1content () BufferContent](apg-waits.lockbuffercontent.md).
**LWLock:buffer\$1content ----sep----:buffer\$1mapping**
Ein Backend-Prozess wartet darauf, einen Datenblock mit einem Puffer im gemeinsam genutzten Pufferpool zu verknüpfen. Weitere Informationen finden Sie unter [LWLock:buffer\$1mapping](apg-waits.lwl-buffer-mapping.md).
**LWLock:buffer\$1mapping ----sep----:BufferIO**
Ein Backend-Prozess möchte eine Seite in den gemeinsam genutzten Speicher einlesen. Der Prozess wartet darauf, dass andere Prozesse ihre Arbeit I/O für die Seite beenden. Weitere Informationen finden Sie unter [LWLock:BufferIO (IPC:BufferIO)](apg-waits.lwlockbufferio.md).
**LWLockDer Prozess wartet darauf, dass andere Prozesse ihre Arbeit für die Seite beenden. ----sep----:Checkpoint**
Ein Prozess wartet darauf, einen Checkpoint zu starten.
**LWLock:CheckpointLock**
Ein Prozess wartet darauf, einen Checkpoint auszuführen.
**LWLock:CheckpointerComm**
Ein Prozess wartet darauf, `fsync` Anfragen zu verwalten.
**LWLock:CheckpointerCommLock**
Ein Prozess wartet darauf, `fsync` Anfragen zu verwalten.
**LWLock:Checkpoint ----sep----:Holzschuh**
Ein Prozess wartet I/O auf einen Clog-Puffer (Transaktionsstatus).
**LWLock:CLogControlLock**
Ein Prozess wartet darauf, den Transaktionsstatus zu lesen oder zu aktualisieren.
**LWLock:CLogTruncationLock**
Ein Prozess wartet darauf, `txid_status` auszuführen oder die älteste verfügbare Transaktions-ID zu aktualisieren.
**LWLockEin Prozess wartet auf einen Clog-Puffer (Transaktionsstatus). ----sep----:commit\$1timestamp**
Ein Prozess wartet auf einen I/O Commit-Zeitstempelpuffer.
**LWLock:CommitTs**
Ein Prozess wartet darauf, den letzten für einen Transaktions-Commit-Zeitstempel festgelegten Wert zu lesen oder zu aktualisieren.
**LWLock:CommitTsBuffer**
Ein Prozess wartet I/O auf einen einfachen Puffer, der zuletzt zuletzt verwendet wurde (SLRU), auf einen Commit-Zeitstempel.
**LWLock:CommitTsControlLock**
Ein Prozess wartet darauf, Transaktions-Commit-Zeitstempel zu lesen oder zu aktualisieren.
**LWLock:CommitTsLock**
Ein Prozess wartet darauf, den letzten für den Transaktionszeitstempel festgelegten Wert zu lesen oder zu aktualisieren.
**LWLock: SLRU CommitTs**
Ein Prozess wartet auf den Zugriff auf den einfachen, selten verwendeten Cache (SLRU-Cache) für einen Commit-Zeitstempel.
**LWLock:ControlFile**
Ein Prozess wartet darauf, die Datei `pg_control` zu lesen oder zu aktualisieren oder eine neue Write-Ahead-Log-Datei (WAL) zu erstellen.
**LWLock:ControlFileLock**
Ein Prozess wartet darauf, die Steuerdatei zu lesen oder zu aktualisieren oder eine neue Write-Ahead-Protokolldatei (WAL) zu erstellen.
**LWLock:DynamicSharedMemoryControl**
Ein Prozess wartet darauf, Informationen zur Zuordnung des dynamischen gemeinsamen Speichers zu lesen oder zu aktualisieren.
**LWLock:DynamicSharedMemoryControlLock**
Ein Prozess wartet darauf, den Status des dynamischen gemeinsam genutzten Speichers zu lesen oder zu aktualisieren.
**LWLock: SLRU ----sep----:lock\$1manager**
Ein Backend-Prozess wartet darauf, Sperren für Backend-Prozesse hinzuzufügen oder zu untersuchen. Oder er wartet darauf, einer Sperrgruppe beizutreten oder diese zu verlassen, die von der parallelen Abfrage verwendet wird. Weitere Informationen finden Sie unter [LWLock:lock\$1manager](apg-waits.lw-lock-manager.md).
**LWLock:LockFastPath**
Ein Prozess wartet darauf, die Informationen zur Fast-Path-Sperre eines Prozesses zu lesen oder zu aktualisieren.
**LWLock:LogicalRepWorker**
Ein Prozess wartet darauf, den Status der logischen Replikations-Arbeitsprozesse zu lesen oder zu aktualisieren.
**LWLock:LogicalRepWorkerLock**
Ein Prozess wartet darauf, dass eine Aktion auf einem logischen Replikations-Worker beendet wird.
**LWLock:LogicalSchemaCache**
Ein Prozess hat den Schema-Cache geändert.
**LWLock:lock\$1manager ----sep----:multixact\$1member**
Ein Prozess wartet auf einen Multixact\$1Member-Puffer I/O .
**LWLockEin Prozess wartet auf einen Multixact\$1Member-Puffer. ----sep----:multixact\$1offset**
Ein Prozess wartet auf einen I/O Multixact-Offset-Puffer.
**LWLock:MultiXactGen**
Ein Prozess wartet darauf, den freigegebenen multixact-Status zu lesen oder zu aktualisieren.
**LWLock:MultiXactGenLock**
Ein Prozess wartet darauf, einen gemeinsam genutzten multixact-Zustand zu lesen oder zu aktualisieren.
**LWLock:MultiXactMemberBuffer**
Ein Prozess wartet I/O auf einen einfachen SLRU-Puffer (Least-Recently Used) für ein Multixact-Mitglied. Weitere Informationen finden Sie unter [LWLock:MultiXact](apg-waits.lwlockmultixact.md).
**LWLock:MultiXactMemberControlLock**
Ein Prozess wartet darauf, Multixact-Mitgliederzuordnungen zu lesen oder zu aktualisieren.
**LWLock: SLRU MultiXactMember**
– Ein Prozess wartet darauf, auf den einfachen, selten verwendeten Cache (SLRU-Cache) für ein Multixact-Mitglied zuzugreifen. Weitere Informationen finden Sie unter [LWLock:MultiXact](apg-waits.lwlockmultixact.md).
**LWLock:MultiXactOffsetBuffer**
Ein Prozess wartet I/O auf einen einfachen Puffer, der zuletzt zuletzt benutzt wurde (SLRU), auf einen Multixact-Offset. Weitere Informationen finden Sie unter [LWLock:MultiXact](apg-waits.lwlockmultixact.md).
**LWLock:MultiXactOffsetControlLock**
Ein Prozess wartet darauf, multixact Offset-Mappings zu lesen oder zu aktualisieren.
**LWLock: SLRU MultiXactOffset**
– Ein Prozess wartet darauf, auf den einfachen, selten verwendeten Cache (SLRU-Cache) für ein Multixact-Offset zuzugreifen. Weitere Informationen finden Sie unter [LWLock:MultiXact](apg-waits.lwlockmultixact.md).
**LWLock:MultiXactTruncation**
Ein Prozess wartet darauf, multixact-Informationen zu lesen oder abzuschneiden.
**LWLock:MultiXactTruncationLock**
Ein Prozess wartet darauf, multixact-Informationen zu lesen oder abzuschneiden.
**LWLock:NotifyBuffer**
Ein Prozess wartet I/O im SLRU-Puffer (Simple Least-Recently Used) auf eine NOTIFY-Nachricht.
**LWLock:NotifyQueue**
Ein Prozess wartet darauf, NOTIFY-Nachrichten zu lesen oder zu aktualisieren.
**LWLock:NotifyQueueTail**
Ein Prozess wartet darauf, einen Grenzwert für den NOTIFY-Nachrichtenspeicher zu aktualisieren.
**LWLock:NotifyQueueTailLock**
Ein Prozess wartet darauf, das Limit für den Speicher von Benachrichtigungsnachrichten zu aktualisieren.
**LWLockEin Prozess wartet auf dem einfachen, zuletzt verwendeten (SLRU) -Puffer auf eine NOTIFY-Nachricht. ----sep----:notifySLRU**
Ein Prozess wartet darauf, auf den einfachen, selten verwendeten Cache (SLRU-Cache) für eine NOTIFY-Nachricht zuzugreifen.
**LWLock:OidGen**
Ein Prozess wartet darauf, eine neue Objekt-ID (OID) zuzuweisen.
**LWLock:OidGenLock**
Ein Prozess wartet darauf, eine Objekt-ID (OID) zuzuweisen oder zuzuweisen.
**LWLock:notifyslru ----sep----:oldserxid**
Ein Prozess wartet auf einen I/O oldserxid-Puffer.
**LWLock:OldSerXidLock**
Ein Prozess wartet darauf, in Konflikt stehende serialisierbare Transaktionen zu lesen oder aufzuzeichnen.
**LWLock:OldSnapshotTimeMap**
Ein Prozess wartet darauf, alte Snapshot-Steuerungsinformationen zu lesen oder zu aktualisieren.
**LWLock:OldSnapshotTimeMapLock**
Ein Prozess wartet darauf, alte Snapshot-Steuerungsinformationen zu lesen oder zu aktualisieren.
**LWLockEin Prozess wartet auf einen oldserxid-Puffer. ----sep----:parallel\$1append**
Ein Prozess wartet darauf, während der parallelen Ausführung des Anhänge-Plans den nächsten Unterplan auszuwählen.
**LWLock:parallel\$1append ----sep----:parallel\$1hash\$1join**
Ein Prozess wartet darauf, während einer parallelen Hash-Plan-Ausführung einen Speicherblock zuzuweisen oder auszutauschen oder Zähler zu aktualisieren.
**LWLock:parallel\$1hash\$1join ----sep----:parallel\$1query\$1dsa**
Ein Prozess wartet auf eine Sperre für die dynamische Shared Memory-Zuweisung für eine parallele Abfrage.
**LWLock:ParallelAppend**
Ein Prozess wartet darauf, während der parallelen Ausführung des Anhänge-Plans den nächsten Unterplan auszuwählen.
**LWLock:ParallelHashJoin**
Ein Prozess wartet darauf, während der Planausführung Worker für einen parallelen Hash-Join zu synchronisieren.
**Sperre: DSA ParallelQuery**
Ein Prozess wartet auf eine dynamische Shared Memory-Zuweisung für eine parallele Abfrage.
**Lwlock: DSA PerSession**
Ein Prozess wartet auf eine dynamische Shared Memory-Zuweisung für eine parallele Abfrage.
**Lwlock: PerSessionRecordType**
Ein Prozess wartet darauf, auf die Informationen einer parallelen Abfrage zu zusammengesetzten Typen zuzugreifen.
**Lwlock: PerSessionRecordTypmod**
Ein Prozess wartet darauf, auf die Informationen einer parallelen Abfrage über Typmodifizierer zuzugreifen, die anonyme Datensatztypen identifizieren.
**Lwlock: PerXactPredicateList**
Ein Prozess wartet darauf, während einer parallelen Abfrage auf die Liste der Prädikatssperren zuzugreifen, die von der aktuellen serialisierbaren Transaktion gehalten werden.
**Lwlock:predicate\$1lock\$1manager**
Ein Prozess wartet darauf, Informationen zur Prädikatsperre hinzuzufügen oder zu untersuchen.
**Lwlock: PredicateLockManager**
Ein Prozess wartet darauf, auf Prädikats-Sperrinformationen zuzugreifen, die von serialisierbaren Transaktionen verwendet werden.
**Lwlock:proc**
Ein Prozess wartet darauf, die Fast-Path-Sperrinformationen zu lesen oder zu aktualisieren.
**LWLock:ProcArray**
Ein Prozess wartet darauf, auf die freigegebenen prozessbezogenen Datenstrukturen zuzugreifen (normalerweise um einen Snapshot zu erhalten oder die Transaktions-ID einer Sitzung zu melden).
**LWLock:ProcArrayLock**
Ein Prozess wartet darauf, einen Snapshot zu erhalten oder eine Transaktions-ID am Ende einer Transaktion zu löschen.
**LWLock:RelationMapping**
Ein Prozess wartet darauf, eine `pg_filenode.map`-Datei zu lesen oder zu aktualisieren (wird verwendet, um die Dateiknotenzuordnungen bestimmter Systemkataloge zu verfolgen).
**LWLock:RelationMappingLock**
Ein Prozess wartet darauf, die Relation-Map-Datei zu aktualisieren, die zum Speichern der catalog-to-file-node Zuordnung verwendet wird.
**LWLock:RelCacheInit**
Ein Prozess wartet darauf, eine `pg_internal.init`-Datei zu lesen oder zu aktualisieren (eine Initialisierungsdatei für den Beziehungscache).
**LWLock:RelCacheInitLock**
Ein Prozess wartet darauf, eine Initialisierungsdatei für den Beziehungscache zu lesen oder zu schreiben.
**LWLockEin Prozess wartet darauf, die Relationszuordnungsdatei zu aktualisieren, die zum Speichern der Zuordnung verwendet wird. ----sep----:replication\$1origin**
Ein Prozess wartet darauf, den Replikationsfortschritt zu lesen oder zu aktualisieren.
**LWLock:replication\$1origin ----sep----:replication\$1slot\$1io**
Auf einen Replikationsslot wartet ein Prozess. I/O
**LWLock:ReplicationOrigin**
Ein Prozess wartet darauf, einen Replikationsursprung zu erstellen, zu löschen oder zu verwenden.
**LWLock:ReplicationOriginLock**
Ein Prozess wartet darauf, einen Replikationsursprung einzurichten, zu löschen oder zu verwenden.
**LWLock:ReplicationOriginState**
Ein Prozess wartet darauf, den Fortschritt eines Replikationsursprungs zu lesen oder zu aktualisieren.
**LWLock:ReplicationSlotAllocation**
Ein Prozess wartet darauf, einen Replikations-Slot zuzuweisen oder freizugeben.
**LWLock:ReplicationSlotAllocationLock**
Ein Prozess wartet darauf, einen Replikations-Slot zuzuweisen oder freizugeben.
**LWLock:ReplicationSlotControl**
Ein Prozess wartet darauf, einen Replikations-Slot-Status zu lesen oder zu aktualisieren.
**LWLock:ReplicationSlotControlLock**
Ein Prozess wartet darauf, den Status des Replikations-Slots zu lesen oder zu aktualisieren.
**LWLock: ReplicationSlot IO**
I/O Auf einen Replikationssteckplatz wartet ein Prozess.
**LWLock:SerialBuffer**
Ein Prozess wartet I/O auf einen SLRU-Puffer (Simple Least-Recently Used) für einen serialisierbaren Transaktionskonflikt.
**LWLock:SerializableFinishedList**
Ein Prozess wartet darauf, auf die Liste der abgeschlossenen serialisierbaren Transaktionen zuzugreifen.
**LWLock:SerializableFinishedListLock**
Ein Prozess wartet darauf, auf die Liste der abgeschlossenen serialisierbaren Transaktionen zuzugreifen.
**LWLock:SerializablePredicateList**
Ein Prozess wartet darauf, auf die Liste der Prädikatssperren zuzugreifen, die von serialisierbaren Transaktionen gehalten werden.
**LWLock:SerializablePredicateLockListLock**
Ein Prozess wartet darauf, eine Operation für eine Liste von Sperren auszuführen, die von serialisierbaren Transaktionen gehalten werden.
**LWLock:SerializableXactHash**
Ein Prozess wartet darauf, Informationen zu serialisierbaren Transaktionen zu lesen oder zu aktualisieren.
**LWLock:SerializableXactHashLock**
Ein Prozess wartet darauf, Informationen zu serialisierbaren Transaktionen abzurufen oder zu speichern.
**LWLockEin Prozess wartet auf einen einfachen, zuletzt verwendeten (SLRU) -Puffer für einen serialisierbaren Transaktionskonflikt. ----sep----:serialSLRU**
Ein Prozess wartet auf den Zugriff auf den einfachen, selten verwendeten Cache (SLRU-Cache) für einen serialisierbaren Transaktionskonflikt.
**LWLock:SharedTidBitmap**
Ein Prozess wartet darauf, während einer parallelen Bitmap-Indexabtastung auf eine Bitmap mit gemeinsam genutzten Tupelidentifizierern (TID) zuzugreifen.
**LWLock:SharedTupleStore**
Ein Prozess wartet während einer parallelen Abfrage darauf, auf einen gemeinsam genutzten Tupelspeicher zuzugreifen.
**LWLock:ShmemIndex**
Ein Prozess wartet darauf, Speicherplatz im gemeinsam genutzten Speicher zu finden oder zuzuweisen.
**LWLock:ShmemIndexLock**
Ein Prozess wartet darauf, Speicherplatz im gemeinsam genutzten Speicher zu finden oder zuzuweisen.
**LWLock: Lesen SInval**
Ein Prozess wartet darauf, Nachrichten aus der freigegebenen Katalog-Invalidierungswarteschlange abzurufen.
**LWLock:SInvalReadLock**
Ein Prozess wartet darauf, Nachrichten aus einer gemeinsam genutzten Invalidierungswarteschlange abzurufen oder zu entfernen.
**LWLock: SInval Schreiben**
Ein Prozess wartet darauf, der gemeinsam genutzten Katalog-Invalidierungswarteschlange eine Nachricht hinzuzufügen.
**LWLock:SInvalWriteLock**
Ein Prozess wartet darauf, eine Nachricht in eine gemeinsam genutzte Invalidierungswarteschlange hinzuzufügen.
**LWLock:SyncRep**
Ein Prozess wartet darauf, Informationen zum Status der synchronen Replikation zu lesen oder zu aktualisieren.
**LWLock:SyncRepLock**
Ein Prozess wartet darauf, Informationen zu synchronen Replikaten zu lesen oder zu aktualisieren.
**LWLock:SyncScan**
Ein Prozess wartet darauf, den Startort eines synchronisierten Tabellenscans auszuwählen.
**LWLock:SyncScanLock**
Ein Prozess wartet darauf, die Startposition eines Scans in einer Tabelle für synchronisierte Scans abzurufen.
**LWLock:TablespaceCreate**
Ein Prozess wartet darauf, einen Tablespace zu erstellen oder zu löschen.
**LWLock:TablespaceCreateLock**
Ein Prozess wartet darauf, den Tablespace zu erstellen oder zu löschen.
**LWLock: Schreiben Sie ----sep----:tbm**
Ein Prozess wartet auf eine gemeinsame Iteratorsperre für eine Baum-Bitmap (TBM).
**LWLock:TwoPhaseState**
Ein Prozess wartet darauf, den Status vorbereiteter Transaktionen zu lesen oder zu aktualisieren.
**LWLock:TwoPhaseStateLock**
Ein Prozess wartet darauf, den Status vorbereiteter Transaktionen zu lesen oder zu aktualisieren.
**LWLock:tbm ----sep----:wal\$1insert**
Ein Prozess wartet darauf, das Write-Ahead-Log (WAL) in einen Speicherpuffer einzufügen.
**LWLock: Kartierung WALBuf**
Ein Prozess wartet darauf, eine Seite in Write-Ahead-Log(WAL)-Puffern zu ersetzen.
**LWLock:WALBufMappingLock**
Ein Prozess wartet darauf, eine Seite in Write-Ahead-Log(WAL)-Puffern zu ersetzen.
**LWLock:WALInsert**
Ein Prozess wartet darauf, Write-Ahead-Protokolldaten (WAL) in einen Speicherpuffer einzufügen.
**LWLock:WALWrite**
Ein Prozess wartet darauf, dass Write-Ahead-Protokoll-Puffer (WAL) auf die Platte geschrieben werden.
**LWLock: WALWrite Sperren**
Ein Prozess wartet darauf, dass Write-Ahead-Protokoll-Puffer (WAL) auf die Platte geschrieben werden.
**LWLock:WrapLimitsVacuum**
Ein Prozess wartet darauf, die Limits für Transaktions-ID und Multixact-Verbrauch zu aktualisieren.
**LWLock:WrapLimitsVacuumLock**
Ein Prozess wartet darauf, die Limits für Transaktions-ID und Multixact-Verbrauch zu aktualisieren.
**LWLock:XactBuffer**
Ein Prozess wartet in einem einfachen Puffer, I/O der zuletzt zuletzt verwendet wurde (SLRU), auf einen Transaktionsstatus.
**LWLockEin Prozess wartet auf einen einfachen Puffer, der zuletzt zuletzt verwendet wurde (SLRU), auf einen Transaktionsstatus. ----sep----:xactSLRU**
Ein Prozess wartet darauf, für einen Transaktionsstatus auf den einfachen, selten verwendeten Cache (SLRU-Cache) zuzugreifen.
**LWLock:XactTruncation**
Ein Prozess wartet darauf, pg\$1xact\$1status auszuführen oder die älteste verfügbare Transaktions-ID zu aktualisieren.
**LWLock:XidGen**
Ein Prozess wartet darauf, eine neue Transaktions-ID zuzuweisen.
**LWLock:XidGenLock**
Ein Prozess wartet darauf, eine Transaktions-ID zu vergeben oder zuzuweisen.
**Auszeit: BaseBackupThrottle**
Ein Prozess wartet während der Basissicherung, wenn die Aktivität gedrosselt wird.
**Auszeit: PgSleep**
Ein Backend-Prozess hat die Funktion pg\$1sleep aufgerufen und wartet auf das Ablaufen des Sleep-Timeouts. Weitere Informationen finden Sie unter [Timeout:PgSleep](apg-waits.timeoutpgsleep.md).
**Auszeit: RecoveryApplyDelay**
Ein Prozess wartet aufgrund einer Verzögerungseinstellung darauf, während der Wiederherstellung ein Write-Ahead-Protokoll (WAL) anzuwenden.
**Auszeit: RecoveryRetrieveRetryInterval**
Ein Prozess wartet während der Wiederherstellung, wenn Write-Ahead-Protokoll-Daten (WAL) von keiner Quelle (pg\$1wal, Archiv oder Stream) verfügbar sind.
**Auszeit: VacuumDelay**
Ein Prozess wartet in einem preis-basierten Vakuum-Verzögerungspunkt.
Eine vollständige Liste der PostgreSQL-Warteereignisse finden Sie unter [Der Statistikkollektor > Warteereignistabellen](https://www.postgresql.org/docs/current/monitoring-stats.html#WAIT-EVENT-TABLE) in der PostgreSQL-Dokumentation.