Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Référence d’Amazon Aurora PostgreSQL
Les rubriques suivantes fournissent des informations sur les classements, les fonctions, les paramètres et les événements d’attente dans Amazon Aurora PostgreSQL.
**Topics**
+ [Classements Aurora PostgreSQL pour EBCDIC et autres migrations de mainframe](#AuroraPostgreSQL.Reference.Collations.mainframe.migration)
+ [Collations prises en charge dans Aurora PostgreSQL RDS pour](PostgreSQL-Collations.md)
+ [Référence sur les fonctions Aurora PostgreSQL](Appendix.AuroraPostgreSQL.Functions.md)
+ [Paramètres Amazon Aurora PostgreSQL.](AuroraPostgreSQL.Reference.ParameterGroups.md)
+ [Événements d’attente Amazon Aurora PostgreSQL](AuroraPostgreSQL.Reference.Waitevents.md)
## Classements Aurora PostgreSQL pour EBCDIC et autres migrations de mainframe
La migration des applications mainframe vers de nouvelles plateformes telles qu’AWS préserve en général le comportement des applications. Pour préserver le comportement de l’application sur une nouvelle plateforme exactement comme il l’était sur le mainframe, il faut que les données migrées soient assemblées en utilisant les mêmes règles d’assemblage et de tri. Par exemple, de nombreuses solutions de migration Db2 déplacent les valeurs nulles vers u0180 (position Unicode 0180), de sorte que ces classements trient u0180 en premier. C’est un exemple de la façon dont les classements peuvent varier par rapport à leur source mainframe et de la raison pour laquelle il est nécessaire de choisir un classement qui correspond mieux au classement EBCDIC original.
Aurora PostgreSQL 14.3 et les versions ultérieures fournissent de nombreux classements ICU et EBCDIC pour prendre en charge une telle migration vers AWS en utilisant le service AWS Mainframe Modernization. Pour en savoir plus sur ce service, consultez [Qu’est-ce que AWS Mainframe Modernization ?](https://docs.aws.amazon.com/m2/latest/userguide/what-is-m2.html)
Dans le tableau suivant, vous pouvez trouver les classements fournis par Aurora PostgreSQL. Ces classements suivent les règles EBCDIC et garantissent que les applications de mainframe fonctionnent de la même manière sur AWS que dans l’environnement du mainframe. Le nom du classement comprend la page de code correspondante (cp*nnnn*), ce qui vous permet de choisir le classement approprié pour votre source mainframe. Par exemple, utilisez `en-US-cp037-x-icu` pour obtenir le classement des données EBCDIC provenant d’une application mainframe qui utilise la page de code 037.
| Classements EBCDIC | Classements AWS Blu Age | Classements AWS Micro Focus |
| --- | --- | --- |
| da-DK-cp1142-x-icu | da-DK-cp1142b-x-icu | da-DK-cp1142m-x-icu |
| da-DK-cp277-x-icu | da-DK-cp277b-x-icu | – |
| de-DE-cp1141-x-icu | de-DE-cp1141b-x-icu | de-DE-cp1141m-x-icu |
| de-DE-cp273-x-icu | de-DE-cp273b-x-icu | – |
| en-GB-cp1146-x-icu | en-GB-cp1146b-x-icu | en-GB-cp1146m-x-icu |
| en-GB-cp285-x-icu | en-GB-cp285b-x-icu | – |
| en-US-cp037-x-icu | en-US-cp037b-x-icu | – |
| en-US-cp1140-x-icu | en-US-cp1140b-x-icu | en-US-cp1140m-x-icu |
| es-ES-cp1145-x-icu | es-ES-cp1145b-x-icu | es-ES-cp1145m-x-icu |
| es-ES-cp284-x-icu | es-ES-cp284b-x-icu | – |
| fi-FI-cp1143-x-icu | fi-FI-cp1143b-x-icu | fi-FI-cp1143m-x-icu |
| fi-FI-cp278-x-icu | fi-FI-cp278b-x-icu | – |
| fr-FR-cp1147-x-icu | fr-FR-cp1147b-x-icu | fr-FR-cp1147m-x-icu |
| fr-FR-cp297-x-icu | fr-FR-cp297b-x-icu | – |
| it-IT-cp1144-x-icu | it-IT-cp1144b-x-icu | it-IT-cp1144m-x-icu |
| it-IT-cp280-x-icu | it-IT-cp280b-x-icu | – |
| nl-BE-cp1148-x-icu | nl-BE-cp1148b-x-icu | nl-BE-cp1148m-x-icu |
| nl-BE-cp500-x-icu | nl-BE-cp500b-x-icu | – |
Pour en savoir plus sur AWS Blu Age, consultez [Tutoriel : runtime géré pour AWS Blu Age](https://docs.aws.amazon.com/m2/latest/userguide/tutorial-runtime-ba.html) dans le *Guide de l’utilisateur AWS Mainframe Modernization*.
Pour obtenir plus d’informations sur l’utilisation de AWS Micro Focus, consultez [Tutorial: Managed Runtime for Micro Focus](https://docs.aws.amazon.com/m2/latest/userguide/tutorial-runtime.html) (Tutoriel : runtime géré pour Micro Focus) dans le *Guide de l’utilisateur AWS Mainframe Modernization*.
Pour plus d’informations sur la gestion des classements dans PostgreSQL, consultez [Collation Support](https://www.postgresql.org/docs/current/collation.html) (Prise en charge des classements) dans la documentation de PostgreSQL.
# Collations prises en charge dans Aurora PostgreSQL RDS pour
Les classements sont un ensemble de règles qui déterminent la manière dont les chaînes de caractères stockées dans la base de données sont triées et comparées. Les classements jouent un rôle fondamental dans le système informatique et sont inclus dans le système d’exploitation. Les classements changent au fil du temps lorsque de nouveaux caractères sont ajoutés aux langues ou lorsque les règles de classement changent.
Les bibliothèques de classement définissent des règles et des algorithmes spécifiques pour un classement. Les bibliothèques de classement les plus populaires utilisées dans PostgreSQL sont GNU C (glibc) et les composants d’internationalisation pour Unicode (ICU). Par défaut, Aurora PostgreSQL utilise le classement glibc qui inclut les ordres de tri des caractères Unicode pour les séquences de caractères multi-octets.
Lorsque vous créez un nouveau cluster de bases de données Aurora PostgreSQL, le classement disponible est vérifié dans le système d’exploitation. Les paramètres PostgreSQL de la commande `CREATE DATABASE` `LC_COLLATE` et `LC_CTYPE` sont utilisés pour spécifier un classement, qui constitue le classement par défaut dans cette base de données. Vous pouvez également utiliser le paramètre `LOCALE` dans `CREATE DATABASE` pour définir ces paramètres. Cela détermine le classement par défaut pour les chaînes de caractères dans la base de données et les règles de classification des caractères sous forme de lettres, de chiffres ou de symboles. Vous pouvez également choisir un classement à utiliser sur une colonne, un index ou une requête.
Aurora PostgreSQL dépend de la bibliothèque glibc du système d’exploitation pour la prise en charge du classement. L’instance Aurora PostgreSQL est régulièrement mise à jour avec les dernières versions du système d’exploitation. Ces mises à jour incluent parfois une version plus récente de la bibliothèque glibc. Dans de rares cas, les nouvelles versions de glibc modifient l’ordre de tri ou le classement de certains caractères, ce qui peut entraîner un tri différent des données ou la production d’entrées d’index non valides. Si vous découvrez des problèmes d’ordre de tri pour le classement lors d’une mise à jour, vous devrez peut-être reconstruire les index.
Pour réduire les impacts possibles des mises à jour glibc, Aurora PostgreSQL inclut désormais une bibliothèque de classement par défaut indépendante. Cette bibliothèque de classement est disponible dans Aurora PostgreSQL 14.6, 13.9, 12.13, 11.18 et les versions mineures plus récentes. Elle est compatible avec glibc 2.26-59.amzn2 et assure la stabilité de l’ordre de tri afin d’éviter des résultats de requêtes incorrects.
# Référence sur les fonctions Aurora PostgreSQL
Vous trouverez ci-dessous une liste des fonctions Aurora PostgreSQL disponibles pour vos clusters de bases de données Aurora qui exécutent le moteur de base de données compatible avec l'édition Aurora PostgreSQL. Ces fonctions Aurora PostgreSQL s'ajoutent aux fonctions PostgreSQL standard. Pour de plus amples informations sur les fonctions PostgreSQL standard, consultez [PostgreSQL : fonctions et opérateurs](https://www.postgresql.org/docs/current/functions.html).
## Présentation de
Vous pouvez utiliser les fonctions suivantes pour les instances de base de données Amazon RDS exécutant Aurora PostgreSQL :
+ [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
Indique nom de l'instance de base de données à laquelle vous êtes connecté.
## Syntaxe
```
aurora_db_instance_identifier()
```
## Arguments
Aucun
## Type de retour
Chaîne VARCHAR
## Notes d’utilisation
Cette fonction affiche le nom de l'instance de base de données du cluster d'Aurora Édition compatible avec PostgreSQL pour la connexion de votre client de base de données ou de votre application.
Cette fonction est disponible à partir de la version d'Aurora PostgreSQL 13.7, 12.11, 11.16, 10.21 et pour toutes les autres versions ultérieures.
## Exemples
L'exemple suivant montre les résultats de l'appel de la fonction `aurora_db_instance_identifier`.
```
=> SELECT aurora_db_instance_identifier();
aurora_db_instance_identifier
-------------------------------
test-my-instance-name
```
Vous pouvez joindre les résultats de cette fonction avec la fonction `aurora_replica_status` pour obtenir des détails sur l'instance de base de données pour votre connexion. La fonction [aurora\$1replica\$1status](aurora_replica_status.md) seule ne vous indique pas l'instance de base de données que vous utilisez. L'exemple suivant vous montre comment procéder.
```
=> 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
Affiche l'état du gestionnaire de cache du cluster.
## Syntaxe
```
aurora_ccm_status()
```
## Arguments
Aucune.
## Type de retour
Registre SETOF comprenant les colonnes suivantes :
+ `buffers_sent_last_minute` – Nombre de tampons envoyés au lecteur désigné au cours de la dernière minute.
+ `buffers_found_last_minute` : nombre de tampons fréquemment consultés, identifiés au cours de la dernière minute.
+ `buffers_sent_last_scan` – Nombre de tampons envoyés au lecteur désigné au cours de la dernière analyse terminée du cache du tampon.
+ `buffers_found_last_scan` – Nombre de tampons fréquemment consultés envoyés au cours de la dernière analyse terminée du cache du tampon. Les tampons déjà mis en cache sur le lecteur désigné ne sont pas envoyés.
+ `buffers_sent_current_scan` – Nombre de tampons envoyés au cours de l'analyse actuelle.
+ `buffers_found_current_scan` – Nombre de tampons fréquemment consultés qui ont été identifiés au cours de l'analyse actuelle.
+ `current_scan_progress` – Nombre de tampons visités jusqu'à maintenant au cours de l'analyse actuelle.
## Notes d’utilisation
Vous pouvez utiliser cette fonction pour vérifier et surveiller la fonctionnalité de gestion de cache du cluster (CCM). Cette fonction fonctionne uniquement si la CCM est active sur votre cluster de bases de données Aurora PostgreSQL. Pour utiliser cette fonction, connectez-vous à l'instance de base de données d'écriture sur votre cluster de bases de données Aurora PostgreSQL.
Activez la CCM pour un cluster de bases de données Aurora PostgreSQL en définissant `apg_ccm_enabled` sur 1 dans le groupe de paramètres de cluster de bases de données personnalisé du cluster. Pour savoir comment procéder, veuillez consulter la section [Configuration de la gestion des caches de clusters](AuroraPostgreSQL.cluster-cache-mgmt.md#AuroraPostgreSQL.cluster-cache-mgmt.Configure).
La gestion de cache du cluster est active sur un cluster de bases de données Aurora PostgreSQL lorsque le cluster dispose d'une instance Aurora Reader configurée comme suit :
+ L'instance Aurora Reader utilise le même type et la même taille de classe d'instance de base de données que l'instance d'enregistreur du cluster.
+ L'instance Aurora Reader est configurée en tant que niveau 0 pour le cluster. Si le cluster possède plusieurs lecteurs, il s'agit de son seul lecteur de niveau 0.
La définition de plusieurs lecteurs sur le niveau 0 désactive la CCM. Lorsque la CCM est désactivée, l'appel de cette fonction renvoie le message d'erreur suivant :
```
ERROR: Cluster Cache Manager is disabled
```
Vous pouvez également utiliser l'extension pg\$1buffercache PostgreSQL pour analyser le cache du tampon. Pour plus d'informations, consultez [pg\$1buffercache](https://www.postgresql.org/docs/current/pgbuffercache.html) dans la documentation de PostgreSQL.
Pour plus d'informations, consultez [Introduction to Aurora PostgreSQL cluster cache management](https://aws.amazon.com/blogs/database/introduction-to-aurora-postgresql-cluster-cache-management/).
## Exemples
L'exemple suivant montre les résultats de l'appel de la fonction `aurora_ccm_status`. Ce premier exemple montre les statistiques CCM.
```
=> SELECT * FROM aurora_ccm_status();
buffers_sent_last_minute | buffers_found_last_minute | buffers_sent_last_scan | buffers_found_last_scan | buffers_sent_current_scan | buffers_found_current_scan | current_scan_progress
--------------------------+---------------------------+------------------------+-------------------------+---------------------------+----------------------------+-----------------------
2242000 | 2242003 | 17920442 | 17923410 | 14098000 | 14100964 | 15877443
```
Pour plus de détails, vous pouvez utiliser l'affichage développé, comme indiqué ci-dessous :
```
\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
```
Cet exemple montre comment vérifier le débit d'activation et le pourcentage d'activation.
```
=> 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
Affiche l'état de toutes les instances Aurora, y compris les réplicas dans un cluster de bases de données global Aurora.
## Syntaxe
```
aurora_global_db_instance_status()
```
## Arguments
Aucun
## Type de retour
Registre SETOF comprenant les colonnes suivantes :
+ `server_id` – Identifiant de l'instance de base de données.
+ `session_id` – Identifiant unique de la session en cours. La valeur `MASTER_SESSION_ID` identifie l'instance de base de données d'enregistreur (principale).
+ `aws_region` – La Région AWS dans laquelle cette instance de base de données globale s'exécute. Pour obtenir la liste des régions, consultez [Disponibilité dans les Régions](Concepts.RegionsAndAvailabilityZones.md#Aurora.Overview.Availability).
+ `durable_lsn` – Numéro de séquence de journal (LSN) rendu durable dans le stockage. Un numéro de séquence de journal (LSN) est un numéro séquentiel unique qui identifie un enregistrement dans le journal des transactions de la base de données. Les LSN sont classés de telle sorte qu'un LSN plus grand représente une transaction ultérieure.
+ `highest_lsn_rcvd` – LSN le plus élevé reçu par l'instance de base de données en provenance de l'instance de base de données d'enregistreur.
+ `feedback_epoch` – Époque utilisée par l'instance de base de données lorsqu'elle génère des informations de zone hébergée. Le terme *zone hébergée* fait référence à une instance de base de données qui prend en charge les connexions et les requêtes pendant que la base de données principale est en mode de récupération ou en mode veille. Les informations de zone hébergée incluent l'époque (instant dans le passé) et d'autres détails sur l'instance de base de données utilisée comme une zone hébergée. Pour de plus amples informations, veuillez consulter la documentation PostgreSQL sur [Veille à chaud](https://www.postgresql.org/docs/current/hot-standby.html).
+ `feedback_xmin` – ID de transaction actif minimal (le plus ancien) utilisé par l'instance de base de données.
+ `oldest_read_view_lsn` : le LSN le plus ancien utilisé par l'instance de base de données pour lire à partir du stockage.
+ `visibility_lag_in_msec` – Latence de cette instance de base de données par rapport à l'instance de base de données d'enregistreur en millisecondes.
## Notes d’utilisation
Cette fonction affiche les statistiques de réplication pour un cluster de bases de données Aurora. Pour chaque instance de base de données Aurora PostgreSQL du cluster, la fonction affiche une ligne de données qui inclut tous les réplicas entre régions dans une configuration de base de données globale.
Vous pouvez exécuter cette fonction à partir de n'importe quelle instance d'un cluster de bases de données Aurora PostgreSQL ou d'une base de données globale Aurora PostgreSQL. La fonction renvoie des détails sur la latence décalage pour toutes les instances de réplica.
Pour en savoir plus sur la surveillance de la latence à l'aide de cette fonction (`aurora_global_db_instance_status`) ou de `aurora_global_db_status`, consultez [Surveillance des bases de données globales basées sur Aurora PostgreSQL](aurora-global-database-monitoring.md#aurora-global-database-monitoring.postgres).
Pour plus d'informations sur les bases de données globales Aurora, consultez [Présentation d’Amazon Aurora Global Database](aurora-global-database.md#aurora-global-database-overview).
Pour commencer à utiliser les bases de données globales Aurora, consultez [Mise en route avec Amazon Aurora Global Database](aurora-global-database-getting-started.md) ou la [FAQ Amazon Aurora](https://aws.amazon.com/rds/aurora/faqs/).
## Exemples
Cet exemple montre les statistiques des instances entre régions.
```
=> 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
```
Cet exemple montre comment vérifier la latence de réplica globale en millisecondes.
```
=> 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
```
Cet exemple montre comment vérifier la latence minimale, maximale et moyenne par Région AWS à partir de la configuration de base de données globale.
```
=> 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
Affiche des informations sur divers aspects du retard de la base de données globale Aurora, en particulier le retard du stockage Aurora sous-jacent (appelé « retard de durabilité ») et le retard entre l’objectif de point de reprise (RPO).
## Syntaxe
```
aurora_global_db_status()
```
## Arguments
Aucune.
## Type de retour
Registre SETOF comprenant les colonnes suivantes :
+ `aws_region` : Région AWS dans laquelle se trouve ce cluster de bases de données. Pour obtenir la liste complète des Régions AWS par moteur, consultez [ Régions et zones de disponibilité](Concepts.RegionsAndAvailabilityZones.md).
+ `highest_lsn_written` – Numéro de séquence de journal (LSN) le plus élevé actuellement existant sur ce cluster de bases de données. Un numéro de séquence de journal (LSN) est un numéro séquentiel unique qui identifie un enregistrement dans le journal des transactions de la base de données. Les LSN sont classés de telle sorte qu’un LSN plus grand représente une transaction ultérieure.
+ `durability_lag_in_msec` – Différence dans les valeurs d’horodatage entre `highest_lsn_written` sur un cluster de bases de données secondaire et `highest_lsn_written` sur le cluster de bases de données principal. La valeur -1 identifie le cluster de bases de données principal de la base de données globale Aurora.
+ `rpo_lag_in_msec` : retard de l’objectif de point de reprise (RPO). Le retard RPO correspond au temps nécessaire au stockage de la transaction utilisateur COMMIT la plus récente sur un cluster de bases de données secondaire, après qu’elle a été stockée sur le cluster de bases de données principal de la base de données globale Aurora. La valeur -1 indique le cluster de bases de données principal (le retard n’est donc pas pertinent).
En termes simples, cette métrique calcule l’objectif de point de reprise pour chaque cluster de bases de données Aurora PostgreSQL dans la base de données globale Aurora, c’est-à-dire la quantité de données qui risque d’être perdue en cas de panne. Comme pour la latence, le RPO est mesuré dans le temps.
+ `last_lag_calculation_time` – Horodatage qui spécifie l’heure à laquelle les valeurs ont été calculées pour la dernière fois pour `durability_lag_in_msec` et `rpo_lag_in_msec`. Une valeur temporelle telle que `1970-01-01 00:00:00+00` signifie qu’il s’agit du cluster de bases de données principal.
+ `feedback_epoch` – Époque utilisée par le cluster de bases de données secondaire lorsqu’il génère des informations de zone hébergée. Le terme *zone hébergée* fait référence à une instance de base de données qui prend en charge les connexions et les requêtes pendant que la base de données principale est en mode de récupération ou en mode veille. Les informations de zone hébergée incluent l’époque (instant dans le passé) et d’autres détails sur l’instance de base de données utilisée comme une zone hébergée. Pour plus d’informations, consultez [Veille à chaud](https://www.postgresql.org/docs/current/hot-standby.html) dans la documentation PostgreSQL.
+ `feedback_xmin` – ID de transaction actif minimum (le plus ancien) utilisé par un cluster de bases de données secondaire.
## Notes d’utilisation
Toutes les versions actuellement disponibles d’Aurora PostgreSQL prennent en charge cette fonction. Cette fonction affiche les statistiques de réplication pour une base de données globale Aurora. Elle affiche une ligne pour chaque cluster de bases de données dans une base de données globale Aurora PostgreSQL. Vous pouvez exécuter cette fonction à partir de n’importe quelle instance de votre base de données globale Aurora PostgreSQL.
Pour évaluer la latence de réplication de la base de données globale Aurora, qui est la latence des données visible, consultez [aurora\$1global\$1db\$1instance\$1status](aurora_global_db_instance_status.md).
Pour en savoir plus sur l’utilisation de `aurora_global_db_status` et `aurora_global_db_instance_status` pour surveiller la latence de la base de données globale Aurora, consultez [Surveillance des bases de données globales basées sur Aurora PostgreSQL](aurora-global-database-monitoring.md#aurora-global-database-monitoring.postgres). Pour plus d’informations sur les bases de données globales Aurora, consultez [Présentation d’Amazon Aurora Global Database](aurora-global-database.md#aurora-global-database-overview).
## Exemples
Cet exemple montre comment afficher les statistiques de stockage entre régions.
```
=> 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
Répertorie toutes les fonctions intégrées disponibles d'Aurora PostgreSQL, ainsi que de brèves descriptions et des détails sur les fonctions.
## Syntaxe
```
aurora_list_builtins()
```
## Arguments
Aucun
## Type de retour
Registre SETOF
## Exemples
L'exemple suivant montre les résultats de l'appel de la fonction `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
Affiche l’état de tous les nœuds de lecture Aurora PostgreSQL.
## Syntaxe
```
aurora_replica_status()
```
## Arguments
Aucun
## Type de retour
Registre SETOF avec les colonnes suivantes :
+ `server_id` : l’ID (identifiant) de l’instance de base de données.
+ `session_id` : un identifiant unique pour la séance en cours, renvoyé pour l’instance principale et les instances de lecture comme suit :
+ Pour l’instance principale, `session_id` est toujours égal à ``MASTER_SESSION_ID’`.
+ Pour les instances de lecture, `session_id` est toujours égal au `UUID` (identifiant universel et unique) de l’instance de lecture.
+ `durable_lsn` : le numéro de séquence du journal (LSN) qui a été stocké.
+ Pour le volume principal, le LSN durable du volume principal (VDL) actuellement en vigueur.
+ Pour tout volume secondaire, le VDL du volume principal sur lequel le volume secondaire a été appliqué.
**Note**
Un numéro de séquence de journal (LSN) est un numéro séquentiel unique qui identifie un enregistrement dans le journal des transactions de la base de données. Les LSN sont ordonnés de telle sorte qu’un LSN plus grand représente une transaction qui a eu lieu plus tard dans la séquence.
+ `highest_lsn_rcvd` : le LSN le plus élevé (le plus récent) reçu par l’instance de base de données en provenance de l’instance de base de données en écriture.
+ `current_read_lsn` : le LSN de l’instantané le plus récent qui a été appliqué à tous les lecteurs.
+ `cur_replay_latency_in_usec` : le nombre de microsecondes attendu pour relire le journal sur le volume secondaire.
+ `active_txns` : le nombre de transactions actuellement actives.
+ `is_current` : non utilisé.
+ `last_transport_error` : dernier code d’erreur de réplication.
+ `last_error_timestamp` : horodatage de la dernière erreur de réplication.
+ `last_update_timestamp` : horodatage de la dernière mise à jour de l’état du réplica. Depuis Aurora PostgreSQL 13.9, la valeur de `last_update_timestamp` pour l’instance de base de données à laquelle vous êtes connecté est définie sur `NULL`.
+ `feedback_xmin` : la valeur feedback\$1xmin de secours du réplica. ID de transaction actif minimum (le plus ancien) utilisé par l’instance de base de données.
+ `feedback_epoch` : l’époque utilisée par l’instance de base de données lorsqu’elle génère des informations de secours.
+ `replica_lag_in_msec` : temps de retard de l’instance de lecteur par rapport à l’instance d’enregistreur, en millisecondes.
+ `log_stream_speed_in_kib_per_second` : le débit du flux des journaux en kilo-octets par seconde.
+ `log_buffer_sequence_number` : le numéro de séquence de la mémoire tampon du journal.
+ `oldest_read_view_trx_id` : non utilisé.
+ `oldest_read_view_lsn` : LSN le plus ancien utilisé par l’instance de base de données pour lire à partir du stockage.
+ `pending_read_ios` : les lectures de pages en suspens qui sont toujours en attente sur le réplica.
+ `read_ios` : le nombre total de pages lues sur le réplica.
+ `iops` : non utilisé.
+ `cpu` : utilisation du processeur par le démon de stockage Aurora pour chaque nœud du cluster. Pour plus d’informations sur l’utilisation du CPU par l’instance, consultez [Métriques de niveau instance pour Amazon Aurora](Aurora.AuroraMonitoring.Metrics.md#Aurora.AuroraMySQL.Monitoring.Metrics.instances).
## Notes d’utilisation
Toutes les versions actuellement disponibles d’Aurora PostgreSQL prennent en charge cette fonction. La fonction `aurora_replica_status` renvoie les valeurs du gestionnaire d’état des réplicas d’un cluster de bases de données Aurora PostgreSQL. Vous pouvez utiliser cette fonction pour obtenir des informations sur l’état de la réplication sur votre cluster de bases de données Aurora PostgreSQL, y compris les métriques pour toutes les instances de base de données dans votre cluster de bases de données Aurora. Par exemple, vous pouvez effectuer les opérations suivantes :
+ **Get information about the type of instance (writer, reader) in the Aurora PostgreSQL DB cluster** (Obtenir des informations sur le type d’instance (écriture, lecture) dans le cluster de bases de données Aurora PostgreSQL) : vous pouvez obtenir ces informations en lisant les valeurs des colonnes suivantes :
+ `server_id` : contient le nom de l’instance que vous avez spécifié lorsque vous avez créé l’instance. Dans certains cas, comme pour l’instance principale (écriture), le nom est généralement créé pour vous en ajoutant *-instance-1* au nom spécifié pour votre cluster de bases de données Aurora PostgreSQL.
+ `session_id` : le champ `session_id` indique si l’instance est une instance de lecture ou d’écriture. Pour une instance d’enregistreur, `session_id` est toujours défini sur `"MASTER_SESSION_ID"`. Pour une instance de lecture, `session_id` est défini sur l’`UUID` de l’instance de lecture en question.
+ **Diagnose common replication issues, such as replica lag** (Diagnostiquer les problèmes de réplication courants, tels que le retard de réplica) : le retard de réplica est le temps, en millisecondes, pendant lequel le cache des pages d’une instance de lecture est en retard sur celui de l’instance d’enregistreur. Ce retard se produit parce que les clusters Aurora utilisent la réplication asynchrone, comme décrit dans [Réplication avec Amazon Aurora](Aurora.Replication.md). La valeur est indiquée dans la colonne `replica_lag_in_msec` des résultats renvoyés par cette fonction. Un retard peut également se produire lorsqu’une requête est annulée en raison de conflits avec la récupération sur un serveur de veille. Vous pouvez consulter `pg_stat_database_conflicts()` pour vérifier qu’un tel conflit est à l’origine du retard du réplica (ou non). Pour plus d’informations, consultez [The Statistics Collector](https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-DATABASE-CONFLICTS-VIEW) (Collecteur de statistiques) dans la *documentation de PostgreSQL*. Pour en savoir plus sur la haute disponibilité et la réplication, consultez la [FAQ Amazon Aurora](https://aws.amazon.com/rds/aurora/faqs/#High_Availability_and_Replication).
Amazon CloudWatch enregistre les résultats `replica_lag_in_msec` dans le temps, en tant que métrique `AuroraReplicaLag`. Pour obtenir plus d’informations sur l’utilisation des métriques CloudWatch pour Aurora, consultez [Surveillance des métriques (Amazon Aurora) avec Amazon CloudWatch](monitoring-cloudwatch.md).
Pour en savoir plus sur le dépannage et les redémarrages des réplicas en lecture Aurora, consultez la section [Why did my Amazon Aurora read replica fall behind and restart?](https://aws.amazon.com/premiumsupport/knowledge-center/aurora-read-replica-restart/) (Pourquoi mon réplica en lecture Amazon Aurora a-t-il pris du retard et redémarré ?) dans le [Centre AWS Support](https://console.aws.amazon.com/support/home#/).
## Exemples
L’exemple suivant montre comment obtenir l’état de réplication de toutes les instances d’un cluster de bases de données Aurora PostgreSQL :
```
=> SELECT *
FROM aurora_replica_status();
```
L’exemple suivant montre l’instance d’enregistreur dans le cluster de bases de données Aurora PostgreSQL `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
```
L’exemple suivant répertorie toutes les instances de lecture d’un cluster :
```
=> 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)
```
L’exemple suivant répertorie toutes les instances, le retard de chaque instance par rapport à l’instance d’enregistreur et le temps écoulé depuis la dernière mise à jour :
```
=> 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
Renvoie une ligne par processus serveur, affichant les informations relatives à l’activité actuelle de ce processus.
## Syntaxe
```
aurora_stat_activity();
```
## Arguments
Aucun
## Type de retour
Renvoie une ligne par processus serveur. Outre les colonnes `pg_stat_activity`, le champ suivant est ajouté :
+ planid — identifiant du plan
## Notes d’utilisation
Vue supplémentaire de `pg_stat_activity` renvoyant des mêmes colonnes avec une colonne `plan_id` supplémentaire qui montre le plan d’exécution de la requête.
`aurora_compute_plan_id` doit être activé pour que la vue renvoie un plan\$1id.
Cette fonction est disponible à partir des versions d’Aurora PostgreSQL 14.10, 15.5 et pour toutes les autres versions ultérieures.
## Exemples
L’exemple de requête ci-dessous agrège la charge maximale par query\$1id et 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)
```
Si le plan utilisé pour query\$1id change, un nouveau plan\$1id sera indiqué par aurora\$1stat\$1activity.
```
count | query_id | plan_id
-------+----------------------+-------------
10 | -5471422286312252535 | 1602979607
1 | -6907107586630739258 | -1809935983
1 | -2446282393000597155 | -207532066
(3 rows)
```
# aurora\$1stat\$1backend\$1waits
Affiche les statistiques relatives à l'activité d'attente pour un processus de backend spécifique.
## Syntaxe
```
aurora_stat_backend_waits(pid)
```
## Arguments
`pid` – ID du processus de backend. Vous pouvez obtenir des ID de processus à l'aide de la vue `pg_stat_activity`.
## Type de retour
Registre SETOF comprenant les colonnes suivantes :
+ `type_id` – Nombre qui indique le type d'événement d'attente, tel que `1` pour un verrou léger (`LWLock`), `3` pour un verrou, ou `6` pour une session client, pour en citer quelques exemples. Ces valeurs deviennent significatives lorsque vous joignez les résultats de cette fonction avec des colonnes issues de la fonction `aurora_stat_wait_type`, comme illustré dans les [Exemples](#aurora_stat_backend_waits-examples).
+ `event_id` – Numéro d'identification de l'événement d'attente. Joignez cette valeur aux colonnes issues de `aurora_stat_wait_event` pour obtenir des noms d'événement significatifs.
+ `waits` – Nombre d'attentes cumulées pour l'ID de processus spécifié.
+ `wait_time` – Temps d'attente en millisecondes.
## Notes d’utilisation
Vous pouvez utiliser cette fonction pour analyser des événements d'attente (session) de backend spécifiques, survenus depuis l'ouverture d'une connexion. Pour obtenir des informations plus significatives sur les noms et les types d'événements d'attente, vous pouvez combiner cette fonction `aurora_stat_wait_type` et `aurora_stat_wait_event` à l'aide de JOIN, comme indiqué dans les exemples.
## Exemples
Cet exemple illustre toutes les attentes, tous les types et tous les noms d'événement pour l'ID de processus de backend 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
```
Cet exemple illustre les types d'attentes et les événements d'attente actuels et cumulatifs pour toutes les sessions actives (`pg_stat_activity state <> 'idle'`) (mais sans la session actuelle qui appelle la fonction (`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
```
Cet exemple illustre les trois (3) premiers types d'attente et événements d'attente cumulatifs en cours pour toutes les sessions actives (`pg_stat_activity state <> 'idle'`), à l'exception de la session actuelle (`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` est une vue statistique comprenant des informations sur les écritures dans le cache Optimized Reads.
## Syntaxe
```
aurora_stat_bgwriter()
```
## Arguments
Aucun
## Type de retour
Registre SETOF contenant toutes les colonnes `pg_stat_bgwriter` et les colonnes supplémentaires suivantes. Pour plus d'informations sur les colonnes `pg_stat_bgwriter`, consultez [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).
Vous pouvez réinitialiser les statistiques de cette fonctionnalité en utilisant `pg_stat_reset_shared("bgwriter")`.
+ `orcache_blks_written` : nombre total de blocs de données écrits dans le cache Optimized Reads.
+ `orcache_blk_write_time` : si `track_io_timing` est activé, le temps total passé à écrire des blocs de données dans le cache Optimized Reads est enregistré en millisecondes. Pour plus d'informations, consultez [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
## Notes d’utilisation
Cette fonctionnalité est disponible dans les versions suivantes d'Aurora PostgreSQL :
+ Version 15.4 et versions 15 ultérieures
+ Version 14.9 et versions 14 ultérieures
## Exemples
```
=> select * from aurora_stat_bgwriter();
-[ RECORD 1 ]-----------------+-----------
orcache_blks_written | 246522
orcache_blk_write_time | 339276.404
```
# aurora\$1stat\$1database
Elle contient toutes les colonnes de pg\$1stat\$1database et en ajoute de nouvelles à la fin.
## Syntaxe
```
aurora_stat_database()
```
## Arguments
Aucun
## Type de retour
Registre SETOF contenant toutes les colonnes `pg_stat_database` et les colonnes supplémentaires suivantes. Pour plus d'informations sur les colonnes `pg_stat_database`, consultez [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` : nombre total de blocs partagés lus à partir du stockage Aurora dans cette base de données.
+ `orcache_blks_hit` : nombre total d'accès au cache Optimized Reads dans cette base de données.
+ `local_blks_read` : nombre total de blocs locaux lus dans cette base de données.
+ `storage_blk_read_time` : si `track_io_timing` est activé, le temps total passé à lire des blocs de données à partir du stockage Aurora est enregistré en millisecondes, sinon la valeur est nulle. Pour plus d'informations, consultez [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
+ `local_blk_read_time` : si `track_io_timing` est activé, le temps total passé à lire des blocs de données locales est enregistré en millisecondes, sinon la valeur est nulle. Pour plus d'informations, consultez [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
+ `orcache_blk_read_time` : si `track_io_timing` est activé, le temps total passé à lire des blocs de données à partir du cache Optimized Reads est enregistré en millisecondes, sinon la valeur est nulle. Pour plus d'informations, consultez [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
**Note**
La valeur de `blks_read` est la somme de `storage_blks_read`, `orcache_blks_hit` et `local_blks_read`.
La valeur de `blk_read_time` est la somme de `storage_blk_read_time`, `orcache_blk_read_time` et `local_blk_read_time`.
## Notes d’utilisation
Cette fonctionnalité est disponible dans les versions suivantes d'Aurora PostgreSQL :
+ Version 15.4 et versions 15 ultérieures
+ Version 14.9 et versions 14 ultérieures
## Exemples
L'exemple suivant montre comment elle transporte toutes les colonnes `pg_stat_database` et en ajoute six nouvelles à la fin :
```
=> 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
Indique l'activité cumulative pour chaque type d'opération de langage de manipulation de données (DML) sur une base de données dans un cluster Aurora PostgreSQL.
## Syntaxe
```
aurora_stat_dml_activity(database_oid)
```
## Arguments
*database\$1oid*
ID d'objet (OID) de la base de données dans le cluster Aurora PostgreSQL.
## Type de retour
Registre SETOF
## Notes d’utilisation
La fonction `aurora_stat_dml_activity` est disponible uniquement avec Aurora PostgreSQL version 3.1 compatible avec le moteur PostgreSQL 11.6 et versions ultérieures.
Utilisez cette fonction sur les clusters Aurora PostgreSQL avec un grand nombre de bases de données pour identifier les bases de données qui ont une activité DML supérieure ou plus lente, ou les deux.
La fonction `aurora_stat_dml_activity` renvoie le nombre de fois que les opérations ont été exécutées et la latence cumulative en microsecondes pour les opérations SELECT, INSERT, UPDATE et DELETE. Le rapport inclut uniquement les opérations DML réussies.
Vous pouvez réinitialiser cette statistique à l'aide de la fonction d'accès aux statistiques PostgreSQL `pg_stat_reset`. Vous pouvez vérifier quand cette statistique a été réinitialisée pour la dernière fois à l'aide de la fonction `pg_stat_get_db_stat_reset_time`. Pour plus d'informations sur les fonctions d'accès aux statistiques PostgreSQL, consultez [Collecteur de statistiques](https://www.postgresql.org/docs/9.1/monitoring-stats.html) dans la documentation PostgreSQL.
## Exemples
L'exemple suivant montre comment signaler les statistiques d'activité DML pour la base de données connectée.
```
––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
```
L'exemple suivant montre les statistiques d'activité DML pour toutes les bases de données du cluster Aurora PostgreSQL. Ce groupe comprend deux bases de données, `postgres` et `mydb`. La liste séparée par des virgules correspond aux champs `select_count`, `select_latency_microsecs`, `insert_count`, `insert_latency_microsecs`, `update_count`, `update_latency_microsecs`, `delete_count` et `delete_latency_microsecs`.
Aurora PostgreSQL crée et utilise une base de données système nommée `rdsadmin` pour prendre en charge les opérations administratives telles que les sauvegardes, les restaurations, la surveillance de l'état, la réplication, etc. Ces opérations DML n'ont aucun impact sur votre cluster Aurora PostgreSQL.
```
=> SELECT oid,
datname,
aurora_stat_dml_activity(oid)
FROM pg_database;
oid | datname | aurora_stat_dml_activity
-------+----------------+-----------------------------------------------------------------
14006 | template0 | (,,,,,,,)
16384 | rdsadmin | (2346623,1211703821,4297518,817184554,0,0,0,0)
1 | template1 | (,,,,,,,)
14007 | postgres | (178961,66716329,171065,28876649,519538,1454579206167,1,53027)
16401 | mydb | (200246,64302436,200036,107101855,600000,83659417514,0,0)
```
L'exemple suivant montre les statistiques d'activité DML pour toutes les bases de données, organisées en colonnes pour une meilleure lisibilité.
```
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
```
L'exemple suivant montre la latence cumulative moyenne (latence cumulative divisée par le nombre) pour chaque opération DML pour la base de données avec l'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
Obtient la latence de validation cumulative en microsecondes pour les bases de données PostgreSQL Aurora. La *latence de validation* est mesurée comme le temps entre le moment où un client envoie une demande de validation et le moment où il reçoit la confirmation de validation.
## Syntaxe
```
aurora_stat_get_db_commit_latency(database_oid)
```
## Arguments
*database\$1oid*
ID d'objet (OID) de la base de données Aurora PostgreSQL.
## Type de retour
Registre SETOF
## Notes d’utilisation
Amazon CloudWatch utilise cette fonction pour calculer la latence de validation moyenne. Pour plus d'informations sur les métriques Amazon CloudWatch et sur la manière de résoudre une latence de validation élevée, consultez [Affichage des métriques dans la console Amazon RDS](USER_Monitoring.md) et [Prendre de meilleures décisions concernant Amazon RDS avec les métriques Amazon CloudWatch](https://aws.amazon.com/blogs/database/making-better-decisions-about-amazon-rds-with-amazon-cloudwatch-metrics/).
Vous pouvez réinitialiser cette statistique à l'aide de la fonction d'accès aux statistiques PostgreSQL `pg_stat_reset`. Vous pouvez vérifier quand cette statistique a été réinitialisée pour la dernière fois à l'aide de la fonction `pg_stat_get_db_stat_reset_time`. Pour plus d'informations sur les fonctions d'accès aux statistiques PostgreSQL, consultez [Collecteur de statistiques](https://www.postgresql.org/docs/9.1/monitoring-stats.html) dans la documentation PostgreSQL.
## Exemples
L'exemple suivant obtient la latence de validation cumulative pour chaque base de données dans le cluster `pg_database`.
```
=> SELECT oid,
datname,
aurora_stat_get_db_commit_latency(oid)
FROM pg_database;
oid | datname | aurora_stat_get_db_commit_latency
-------+----------------+-----------------------------------
14006 | template0 | 0
16384 | rdsadmin | 654387789
1 | template1 | 0
16401 | mydb | 229556
69768 | postgres | 22011
```
L'exemple suivant obtient la latence de validation cumulative pour la base de données actuellement connectée. Avant d'appeler la fonction `aurora_stat_get_db_commit_latency`, l'exemple utilise d'abord `\gset` pour définir une variable pour l'argument `oid` et définit sa valeur à partir de la base de données connectée.
```
––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
```
L'exemple suivant obtient la latence de validation cumulative pour la base de données `mydb` dans le cluster `pg_database`. Ensuite, il réinitialise cette statistique à l'aide de la fonction `pg_stat_reset` et affiche les résultats. Enfin, il utilise la fonction `pg_stat_get_db_stat_reset_time` pour vérifier quand cette statistique a été réinitialisée pour la dernière fois.
```
=> 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
Affiche l’utilisation du cache du journal d’écriture anticipée (WAL) par option.
## Syntaxe
```
SELECT * FROM aurora_stat_logical_wal_cache()
```
## Arguments
Aucun
## Type de retour
Registre SETOF comprenant les colonnes suivantes :
+ `name` : nom de l’emplacement de réplication.
+ `active_pid` : ID du processus walsender.
+ `cache_hit` : nombre total d’accès au cache wal depuis la dernière réinitialisation.
+ `cache_miss` : nombre total d’erreurs d’accès au cache wal depuis la dernière réinitialisation.
+ `blks_read` : nombre total de requêtes de lecture de cache wal.
+ `hit_rate` : taux d’accès au cache WAL (cache\$1hit / blks\$1read).
+ `last_reset_timestamp` : dernière fois que le compteur a été remis à zéro.
## Notes d’utilisation
Cette fonction est disponible pour les versions suivantes d’Aurora PostgreSQL.
+ Version 15.2 et toutes les versions ultérieures
+ 14.7 et versions ultérieures
+ 13.8 et versions ultérieures
+ 12.12 et versions ultérieures
+ 11.17 et versions ultérieures
## Exemples
L’exemple suivant montre deux emplacements de réplication avec une seule fonction `aurora_stat_logical_wal_cache` active.
```
=> 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
Signale l'utilisation du contexte de mémoire pour chaque processus PostgreSQL.
## Syntaxe
```
aurora_stat_memctx_usage()
```
## Arguments
Aucun
## Type de retour
Registre SETOF comprenant les colonnes suivantes :
+ `pid` : ID du processus.
+ `name` : nom du contexte de mémoire.
+ `allocated` : nombre d'octets obtenus à partir du sous-système de mémoire sous-jacent par le contexte de mémoire.
+ `used` : nombre d'octets validés vers les clients du contexte de mémoire.
+ `instances` : nombre de contextes existants de ce type.
## Notes d’utilisation
Cette fonction affiche l'utilisation du contexte de mémoire pour chaque processus PostgreSQL. Certains processus sont étiquetés `anonymous`. Les processus ne sont pas exposés car ils contiennent des mots clés restreints.
Cette fonction est disponible à compter des versions suivantes d'Aurora PostgreSQL :
+ Version 15.3 et versions 15 ultérieures
+ Version 14.8 et versions 14 ultérieures
+ Version 13.11 et versions 13 ultérieures
+ Version 12.15 et versions 12 ultérieures
+ Version 11.20 et versions 11 ultérieures
## Exemples
L'exemple suivant montre les résultats de l'appel de la fonction `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)
```
Certains mots clés restreints seront masqués et le résultat se présentera comme suit :
```
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
Cette fonction affiche les statistiques du cache à plusieurs niveaux.
## Syntaxe
```
aurora_stat_optimized_reads_cache()
```
## Arguments
Aucun
## Type de retour
Registre SETOF comprenant les colonnes suivantes :
+ `total_size` : taille totale du cache Optimized Reads.
+ `used_size` : taille de page utilisée dans le cache Optimized Reads.
## Notes d’utilisation
Cette fonctionnalité est disponible dans les versions suivantes d'Aurora PostgreSQL :
+ Version 15.4 et versions 15 ultérieures
+ Version 14.9 et versions 14 ultérieures
## Exemples
Voici un exemple de la sortie d'une instance r6gd.8xlarge :
```
=> select pg_size_pretty(total_size) as total_size, pg_size_pretty(used_size)
as used_size from aurora_stat_optimized_reads_cache();
total_size | used_size
-----------+-----------
1054 GB | 975 GB
```
# aurora\$1stat\$1plans
Renvoie une ligne pour chaque plan d’exécution suivi.
## Syntaxe
```
aurora_stat_plans(
showtext
)
```
## Arguments
+ showtext : affiche le texte de la requête et du plan. Les valeurs valides sont NULL, true ou false. True affiche le texte de la requête et du plan.
## Type de retour
Renvoie une ligne pour chaque plan suivi qui contient toutes les colonnes d’`aurora_stat_statements` et les colonnes supplémentaires suivantes.
+ planid — identifiant du plan
+ explain\$1plan — explique le texte du plan
+ plan\$1type:
+ `no plan` : aucun plan n’a été capturé
+ `estimate` : plan capturé avec estimation des coûts
+ `actual` : plan capturé avec EXPLAIN ANALYZE
+ plan\$1captured\$1time — Dernière fois qu’un plan a été capturé
## Notes d’utilisation
`aurora_compute_plan_id` doit être activé et `pg_stat_statements` doit être dans `shared_preload_libraries` pour que les plans puissent être suivis.
Le nombre de plans disponibles est contrôlé par la valeur définie dans le paramètre `pg_stat_statements.max`. Lorsque `aurora_compute_plan_id` est activé, vous pouvez suivre les plans jusqu’à cette valeur spécifiée dans `aurora_stat_plans`.
Cette fonction est disponible à partir des versions d’Aurora PostgreSQL 14.10, 15.5 et pour toutes les autres versions ultérieures.
## Exemples
Dans l’exemple ci-dessous, les deux plans relatifs à l’identifiant de requête -5471422286312252535 sont capturés et les statistiques des instructions sont suivies par le planid.
```
db1=# select calls, total_exec_time, planid, plan_captured_time, explain_plan
db1-# from aurora_stat_plans(true)
db1-# where queryid = '-5471422286312252535'
calls | total_exec_time | planid | plan_captured_time | explain_plan
---------+--------------------+-------------+-------------------------------+------------------------------------------------------------------
1532632 | 3209846.097107853 | 1602979607 | 2023-10-31 03:27:16.925497+00 | Update on pgbench_branches +
| | | | -> Bitmap Heap Scan on pgbench_branches +
| | | | Recheck Cond: (bid = 76) +
| | | | -> Bitmap Index Scan on pgbench_branches_pkey +
| | | | Index Cond: (bid = 76)
61365 | 124078.18012200127 | -2054628807 | 2023-10-31 03:20:09.85429+00 | Update on pgbench_branches +
| | | | -> Index Scan using pgbench_branches_pkey on pgbench_branches+
| | | | Index Cond: (bid = 17)
```
# aurora\$1stat\$1reset\$1wal\$1cache
Réinitialise le compteur du cache wal logique.
## Syntaxe
Pour réinitialiser un emplacement spécifique
```
SELECT * FROM aurora_stat_reset_wal_cache('slot_name')
```
Pour réinitialiser tous les emplacements
```
SELECT * FROM aurora_stat_reset_wal_cache(NULL)
```
## Arguments
`NULL` ou `slot_name`
## Type de retour
Message d'état, chaîne de texte
+ Réinitialisation du compteur de cache wal logique : message de réussite. Ce texte est renvoyé lorsque la fonction réussit.
+ Emplacement de réplication introuvable. Veuillez réessayer. – Message d'échec Ce texte est renvoyé lorsque la fonction échoue.
## Notes d’utilisation
Cette fonction est disponible pour les versions suivantes.
+ Aurora PostgreSQL 14.5 et versions supérieures
+ Aurora PostgreSQL versions 13.8 et ultérieures
+ Aurora PostgreSQL versions 12.12 et ultérieures
+ Aurora PostgreSQL version 11.17 et ultérieures
## Exemples
L'exemple suivant utilise la fonction `aurora_stat_reset_wal_cache` pour réinitialiser un emplacement nommé `test_results`, puis tente de réinitialiser un emplacement qui n'existe pas.
```
=> 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
Indique l’utilisation des ressources en temps réel, ce qui comprend les métriques des ressources dorsales et l’utilisation du processeur pour tous les processus dorsaux d’Aurora PostgreSQL.
## Syntaxe
```
aurora_stat_resource_usage()
```
## Arguments
Aucun
## Type de retour
Enregistrement SETOF avec colonnes :
+ pid — identifiant du processus
+ allocated\$1memory — mémoire totale allouée par le processus en octets
+ used\$1memory — mémoire réellement utilisée par le processus en octets
+ cpu\$1usage\$1percent — pourcentage d’utilisation du processeur par le processus
## Notes d’utilisation
Cette fonction affiche l’utilisation des ressources dorsales pour chaque processus dorsal d’Aurora PostgreSQL.
Cette fonction est disponible à compter des versions suivantes d’Aurora PostgreSQL :
+ Aurora PostgreSQL 17.5 et versions 17 ultérieures
+ Aurora PostgreSQL 16.9 et versions 16 ultérieures
+ Aurora PostgreSQL 15.13 et versions 15 ultérieures
+ Aurora PostgreSQL 14.18 et versions 14 ultérieures
+ Aurora PostgreSQL 13.21 et versions 13 ultérieures
## Exemples
L’exemple suivant illustre la sortie de la fonction `aurora_stat_resource_usage`.
```
=> select * from aurora_stat_resource_usage();
pid | allocated_memory | used_memory | cpu_usage_percent
------+------------------+-------------+-----------------------
666 | 1074032 | 333544 | 0.00729274882897963
667 | 787312 | 287360 | 0.0029263928146372746
668 | 3076776 | 1563488 | 0.006013116835953961
684 | 803744 | 307480 | 0.002226855426881142
2401 | 1232992 | 943144 | 0
647 | 8000 | 944 | 0.48853387812429855
659 | 319344 | 243000 | 0.0004135602076683591
663 | 262000 | 185736 | 0.008181301476644002
664 | 9024 | 1216 | 0.10992313082653653
(9 rows)
```
# aurora\$1stat\$1statements
Affiche toutes les colonnes `pg_stat_statements` et en ajoute d’autres à la fin.
## Syntaxe
```
aurora_stat_statements(showtext boolean)
```
## Arguments
*showtext boolean*
## Type de retour
Registre SETOF contenant toutes les colonnes `pg_stat_statements` et les colonnes supplémentaires suivantes. Pour plus d’informations sur les colonnes `pg_stat_statements`, consultez [https://www.postgresql.org/docs/current/pgstatstatements.html](https://www.postgresql.org/docs/current/pgstatstatements.html).
Vous pouvez réinitialiser les statistiques de cette fonctionnalité en utilisant `pg_stat_statements_reset()`.
+ `storage_blks_read` : nombre total de blocs partagés lus à partir du stockage Aurora par cette instruction.
+ `orcache_blks_hit` : nombre total d’accès au cache Optimized reads par cette instruction.
+ `storage_blk_read_time` : si `track_io_timing` est activé, le temps total que l’instruction a passé à lire des blocs partagés à partir du stockage Aurora est enregistré en millisecondes. Sinon, la valeur est nulle. Pour plus d’informations, consultez [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
+ `local_blk_read_time` : si `track_io_timing` est activé, le temps total que l’instruction a passé à lire des blocs locaux est enregistré en millisecondes. Sinon, la valeur est nulle. Pour plus d’informations, consultez [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
+ `orcache_blk_read_time` : si `track_io_timing` est activé, le temps total que l’instruction a passé à lire des blocs partagés à partir du cache Optimized Reads est enregistré en millisecondes. Sinon, la valeur est nulle. Pour plus d’informations, consultez [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
+ `total_plan_peakmem` : somme totale des valeurs de pic de mémoire pendant la phase de planification pour tous les appels envoyés à cette instruction. Pour connaître le pic de mémoire moyen lors de la planification de l’instruction, divisez cette valeur par le nombre d’appels.
+ `min_plan_peakmem` : valeur de pic de mémoire la plus faible observée lors de la planification parmi tous les appels transmis à cette instruction.
+ `max_plan_peakmem` : valeur de pic de mémoire la plus élevée observée lors de la planification parmi tous les appels transmis à cette instruction.
+ `total_exec_peakmem` : somme totale des valeurs de pic de mémoire pendant la phase d’exécution pour tous les appels envoyés à cette instruction. Pour connaître le pic de mémoire moyen pendant l’exécution de l’instruction, divisez cette valeur par le nombre d’appels.
+ `min_exec_peakmem` : valeur de pic de mémoire la plus faible, en octets, observée lors de l’exécution parmi tous les appels transmis à cette instruction.
+ `max_exec_peakmem` : valeur de pic de mémoire la plus élevée, en octets, observée lors de l’exécution parmi tous les appels transmis à cette instruction.
**Note**
`total_plan_peakmen`, `min_plan_peakmem` et `max_plan_peakmem` ne sont surveillés que lorsque le paramètre `pg_stat_statements.track_planning` est activé.
## Notes d’utilisation
Pour utiliser la fonction aurora\$1stat\$1statements(), vous devez inclure l’extension `pg_stat_statements` dans le paramètre `shared_preload_libraries`.
Cette fonctionnalité est disponible dans les versions suivantes d’Aurora PostgreSQL :
+ 15.4 et versions 15 ultérieures
+ 14.9 et versions 14 ultérieures
Les colonnes indiquant les pics de mémoire sont disponibles dans les versions suivantes :
+ 16.3 et versions ultérieures
+ 15.7 et versions ultérieures
+ 14.12 et versions ultérieures
## Exemples
L’exemple suivant montre comment elle transporte toutes les colonnes de l’instruction pg\$1stat\$1statements et en ajoute 11 nouvelles à la fin :
```
=> 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
Indique les informations sur les événements d'attente pour l'instance de base de données PostgreSQL Aurora.
## Syntaxe
```
aurora_stat_system_waits()
```
## Arguments
Aucun
## Type de retour
Registre SETOF
## Notes d’utilisation
Cette fonction renvoie le nombre cumulé d'attente et le temps d'attente cumulé pour chaque événement d'attente généré par l'instance de base de données à laquelle vous êtes actuellement connecté.
Le jeu d'enregistrements comprend les champs suivants :
+ `type_id` – ID du type d'événement d'attente.
+ `event_id` – ID de l'événement d'attente.
+ `waits` – Nombre de fois où l'événement d'attente s'est produit.
+ `wait_time` – Temps total en microsecondes passé à attendre cet événement.
Les statistiques renvoyées par cette fonction sont réinitialisées lorsqu'une instance de base de données redémarre.
## Exemples
L'exemple suivant montre les résultats de l'appel de la fonction `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
```
L'exemple suivant montre comment utiliser cette fonction avec `aurora_stat_wait_event` et `aurora_stat_wait_type` pour produire des résultats plus lisibles.
```
=> 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
Répertorie tous les événements d'attente pris en charge pour Aurora PostgreSQL. Pour obtenir des informations sur les événements d'attente Aurora PostgreSQL, consultez [Événements d’attente Amazon Aurora PostgreSQL](AuroraPostgreSQL.Reference.Waitevents.md).
## Syntaxe
```
aurora_stat_wait_event()
```
## Arguments
Aucun
## Type de retour
Registre SETOF comprenant les colonnes suivantes :
+ type\$1id – ID du type d'événement d'attente.
+ event\$1id – ID de l'événement d'attente.
+ type\$1name : nom du type d'attente
+ event\$1name : nom de l'événement d'attente
## Notes d’utilisation
Pour voir les noms d'événements avec le type d'événement au lieu de l'ID, utilisez cette fonction avec d'autres fonctions telles que `aurora_stat_wait_type` et `aurora_stat_system_waits`. Les noms des événements d'attente renvoyés par cette fonction sont les mêmes que ceux renvoyés par la fonction `aurora_wait_report`.
## Exemples
L'exemple suivant montre les résultats de l'appel de la fonction `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
```
L'exemple suivant joint `aurora_stat_wait_type` et `aurora_stat_wait_event` pour renvoyer les noms de type et les noms d'événement pour une meilleure lisibilité.
```
=> 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
Répertorie tous les types d'attentes pris en charge pour Aurora PostgreSQL.
## Syntaxe
```
aurora_stat_wait_type()
```
## Arguments
Aucun
## Type de retour
Registre SETOF comprenant les colonnes suivantes :
+ type\$1id – ID du type d'événement d'attente.
+ type\$1name – nom du type d'attente.
## Notes d’utilisation
Pour voir les noms d'événements d'attente avec le type d'événement d'attente au lieu de l'ID, utilisez cette fonction avec d'autres fonctions telles que `aurora_stat_wait_event` et `aurora_stat_system_waits`. Les noms des types d'attentes renvoyés par cette fonction sont les mêmes que ceux renvoyés par la fonction `aurora_wait_report`.
## Exemples
L'exemple suivant montre les résultats de l'appel de la fonction `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
Renvoie la valeur de chaîne du numéro de version de l'Édition compatible avec PostgreSQL d'Amazon Aurora.
## Syntaxe
```
aurora_version()
```
## Arguments
Aucun
## Type de retour
Chaîne CHAR ou VARCHAR
## Notes d’utilisation
Cette fonction affiche la version du moteur de base de données Amazon Aurora Édition compatible avec PostgreSQL. Le numéro de version est renvoyé sous la forme d'une chaîne de caractères formatée comme *major*.*minor*.*patch*. Pour obtenir plus d'informations sur les numéros de versions d'Aurora PostgreSQL, consultez [Numéro de version Aurora](AuroraPostgreSQL.Updates.md#AuroraPostgreSQL.Updates.Versions.AuroraNumber).
Vous pouvez choisir quand appliquer les mises à niveau de versions mineures en définissant la fenêtre de maintenance pour votre cluster de base de données Aurora PostgreSQL. Pour savoir comment procéder, veuillez consulter la section [Entretien d’un cluster de bases de données Amazon Aurora](USER_UpgradeDBInstance.Maintenance.md).
À partir de la sortie d'Aurora PostgreSQL versions 13.3, 12.8, 11.13, 10.18, et pour toutes les autres versions ultérieures, les numéros de version d'Aurora suivent les numéros de version de PostgreSQL. Pour obtenir plus d'informations sur toutes les versions d'Aurora PostgreSQL, consultez [Amazon Aurora PostgreSQL updates](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Updates.html) (Mises à jour d'Amazon Aurora PostgreSQL) dans les *Notes de mise à jour d'Aurora PostgreSQL*.
## Exemples
L'exemple suivant montre les résultats de l'appel de la fonction `aurora_version` sur un cluster de base de données Aurora PostgreSQL exécutant [PostgreSQL 12.7, Aurora PostgreSQL version 4.2](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Updates.html#AuroraPostgreSQL.Updates.20180305.42), puis de l'exécution de la même fonction sur un cluster exécutant [Aurora PostgreSQL version 13.3](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Updates.html#AuroraPostgreSQL.Updates.20180305.133X).
```
=> SELECT * FROM aurora_version();
aurora_version
----------------
4.2.2
SELECT * FROM aurora_version();
aurora_version
----------------
13.3.0
```
Cet exemple montre comment utiliser la fonction avec diverses options pour obtenir plus de détails sur la version Aurora PostgreSQL. Cet exemple présente un numéro de version d'Aurora distinct du numéro de version de PostgreSQL.
```
=> 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)
```
L'exemple suivant utilise la fonction avec les mêmes options que dans l'exemple précédent. Cet exemple ne présente pas de numéro de version Aurora distinct du numéro de version PostgreSQL.
```
=> 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
Renvoie le numéro de séquence du journal (LSN) utilisé pour identifier le début d'un enregistrement dans le flux de journal d'écriture anticipée (WAL) logique du volume du cluster Aurora.
## Syntaxe
```
aurora_volume_logical_start_lsn()
```
## Arguments
Aucun
## Type de retour
`pg_lsn`
## Notes d’utilisation
Cette fonction identifie le début de l'enregistrement dans le flux WAL logique pour un volume de cluster Aurora donné. Vous pouvez utiliser cette fonction lors de la mise à niveau d'une version majeure à l'aide de la réplication logique et du clonage rapide Aurora afin de déterminer le LSN auquel un instantané ou un clone de base de données est pris. Vous pouvez ensuite utiliser la réplication logique pour diffuser en continu les nouvelles données enregistrées après le numéro LSN et synchroniser les modifications du diffuseur de publication à l'abonné.
Pour plus d'informations sur l'utilisation de la réplication logique pour une mise à niveau de version majeure, consultez [Utilisation de la réplication logique pour effectuer une mise à niveau de version majeure pour Aurora PostgreSQL](AuroraPostgreSQL.MajorVersionUpgrade.md).
Cette fonction est disponible dans les versions suivantes d'Aurora PostgreSQL :
+ Versions 15.2 et 15 ultérieures
+ Versions 14.3 et 14 ultérieures
+ Version 13.6 et versions 13 ultérieures
+ Version 12.10 et versions 12 ultérieures
+ Version 11.15 et versions 11 ultérieures
+ Version 10.20 et versions 10 ultérieures
## Exemples
Vous pouvez obtenir le numéro de séquence du journal (LSN) à l'aide de la requête suivante :
```
postgres=> SELECT aurora_volume_logical_start_lsn();
aurora_volume_logical_start_lsn
---------------
0/402E2F0
(1 row)
```
# aurora\$1wait\$1report
Cette fonction affiche l’activité des événements d’attente sur une période.
## Syntaxe
```
aurora_wait_report([time])
```
## Arguments
*time (optional)* (temps (facultatif))
Le temps en secondes. La valeur par défaut est de 10 secondes.
## Type de retour
Registre SETOF comprenant les colonnes suivantes :
+ type\$1name : nom du type d’attente
+ event\$1name : nom de l’événement d’attente
+ wait : nombre d’attentes
+ wait\$1time : temps d’attente en millisecondes
+ ms\$1per\$1wait : moyenne en millisecondes par nombre d’attentes
+ waits\$1per\$1xact : nombre moyen d’attentes sur le nombre de transactions
+ ms\$1per\$1wait — moyenne en millisecondes par nombre de transactions
## Notes d’utilisation
Cette fonction est disponible à partir de la version 1.1 d’Aurora PostgreSQL compatible avec PostgreSQL 9.6.6 et les versions ultérieures.
Pour utiliser cette fonction, vous devez d’abord créer l’extension Aurora PostgreSQL `aurora_stat_utils` comme suit :
```
=> CREATE extension aurora_stat_utils;
CREATE EXTENSION
```
Pour plus d’informations sur les versions d’extension d’Aurora PostgreSQL disponibles, consultez [Versions d’extension d’Amazon Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Extensions.html) dans *Notes de mise à jour d’Aurora PostgreSQL*.
Cette fonction calcule les événements d’attente au niveau de l’instance en comparant deux instantanés de données statistiques provenant de la fonction aurora\$1stat\$1system\$1waits() et des vues des statistiques PostgreSQL pg\$1stat\$1database.
Pour plus d’informations concernant `aurora_stat_system_waits()` et `pg_stat_database`, consultez [The Statistics Collector](https://www.postgresql.org/docs/current/monitoring-stats.html#PG-STAT-DATABASE-VIEW) (Collecteur de statistiques) dans la *documentation de PostgreSQL*.
Lorsqu’elle est exécutée, cette fonction prend un instantané initial, attend le nombre de secondes spécifié, puis prend un deuxième instantané. La fonction compare les deux instantanés et renvoie la différence. Cette différence représente l’activité de l’instance pour cet intervalle de temps.
Sur l’instance d’enregistreur, la fonction affiche également le nombre de transactions validées et la valeur TPS (transactions par seconde). Cette fonction renvoie des informations au niveau de l’instance et inclut toutes les bases de données sur l’instance.
## Exemples
Cet exemple montre comment créer l’extension aurora\$1stat\$1utils pour utiliser la fonction aurora\$1wait\$1report.
```
=> CREATE extension aurora_stat_utils;
CREATE EXTENSION
```
Cet exemple montre comment consulter le rapport d’attente pour 10 secondes.
```
=> 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
```
Cet exemple montre comment consulter le rapport d’attente pour 60 secondes.
```
=> 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
```
# Paramètres Amazon Aurora PostgreSQL.
Vous gérez votre cluster de bases de données Amazon Aurora PostgreSQL de la même façon que les instances de base de données Amazon RDS, en utilisant les paramètres d’un groupe de paramètres de base de données. Cependant, Amazon Aurora diffère d’Amazon RDS en ce qu’un cluster de bases de données Aurora possède plusieurs instances de base de données. Certains des paramètres que vous utilisez pour gérer votre cluster de bases de données Amazon Aurora s’appliquent à la totalité du cluster, tandis que les autres paramètres s’appliquent uniquement à une instance de base de données spécifique du cluster de bases de données, comme suit :
+ **Groupe de paramètres de cluster de bases de données** : un groupe de paramètres de cluster de bases de données contient l’ensemble des paramètres de configuration du moteur qui s’appliquent à l’ensemble du cluster de bases de données Aurora. Par exemple, la gestion des caches de clusters est une fonction d’un cluster de bases de données Aurora contrôlée par le paramètre `apg_ccm_enabled`, qui fait partie du groupe de paramètres de cluster de bases de données. Le groupe de paramètres de cluster de bases de données contient également les paramètres par défaut du groupe de paramètres de base de données pour les instances de base de données qui composent le cluster.
+ **Groupe de paramètres de base de données** : un groupe de paramètres de base de données est l’ensemble de valeurs de configuration du moteur qui s’appliquent à une instance de base de données spécifique de ce type de moteur. Les groupes de paramètres de base de données du moteur de base de données PostgreSQL sont utilisés par une instance de base de données RDS pour PostgreSQL et un cluster de bases de données Aurora PostgreSQL. Ces paramètres de configuration s’appliquent à des propriétés qui peuvent varier entre les instances de base de données d’un cluster Aurora comme, par exemple, les tailles des mémoires tampons.
Vous gérez les paramètres de niveau cluster dans les groupes de paramètres de cluster de bases de données. Vous gérez les paramètres de niveau instance dans les groupes de paramètres de base de données. Vous pouvez gérer les paramètres à l'aide de la console Amazon RDS, de l' AWS CLI API Amazon RDS ou de l'API Amazon RDS. Il existe des commandes distinctes pour la gestion des paramètres de niveau cluster et des paramètres de niveau instance.
+ [Pour gérer les paramètres au niveau du cluster dans un groupe de paramètres de cluster de base de données, utilisez la modify-db-cluster-parameter commande -group.](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster-parameter-group.html) AWS CLI
+ Pour gérer les paramètres au niveau de l'instance dans un groupe de paramètres de base de données pour une instance de base de données dans un cluster de base de données, utilisez la [modify-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-parameter-group.html) AWS CLI commande.
Pour en savoir plus AWS CLI, consultez la section [Utilisation du AWS CLI dans le](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-using.html) *guide de AWS Command Line Interface l'utilisateur*.
Pour plus d’informations sur les groupes de paramètres, consultez [Groupes de paramètres pour Amazon Aurora](USER_WorkingWithParamGroups.md).
## Affichage des paramètres de cluster de bases de données Aurora PostgreSQL et de base de données
Vous pouvez afficher tous les groupes de paramètres par défaut disponibles pour RDS pour les instances de base de données PostgreSQL et pour les clusters de bases de données Aurora PostgreSQL dans la AWS Management Console. Les groupes de paramètres par défaut pour tous les moteurs de base de données et les types et versions de clusters de base de données sont répertoriés pour chaque AWS région. Tous les groupes de paramètres personnalisés sont également répertoriés.
Plutôt que de les afficher dans le AWS Management Console, vous pouvez également répertorier les paramètres contenus dans les groupes de paramètres de cluster de base de données et les groupes de paramètres de base de données à l'aide de l'API AWS CLI ou de l'API Amazon RDS. Par exemple, pour répertorier les paramètres d'un groupe de paramètres de cluster de base de données, vous devez utiliser la [describe-db-cluster-parameters](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-cluster-parameters.html) AWS CLI commande suivante :
```
aws rds describe-db-cluster-parameters --db-cluster-parameter-group-name default.aurora-postgresql12
```
La commande renvoie des descriptions JSON détaillées de chaque paramètre. Pour réduire la quantité d’informations renvoyées, vous pouvez spécifier ce que vous voulez à l’aide de l’option `--query`. Par exemple, vous pouvez obtenir le nom du paramètre, sa description et les valeurs autorisées pour le groupe de paramètres de cluster de bases de données Aurora PostgreSQL 12 par défaut comme suit :
Pour Linux, macOS ou 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}]'
```
Pour 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}]"
```
Un groupe de paramètres de cluster de bases de données Aurora inclut le groupe de paramètres d’instance de base de données et les valeurs par défaut d’un moteur de base de données Aurora spécifique. Vous pouvez obtenir la liste des paramètres de base de données à partir du même groupe de paramètres par défaut Aurora PostgreSQL par défaut à l'aide de [describe-db-parameters](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-parameters.html) AWS CLI la commande illustrée ci-dessous.
Pour Linux, macOS ou Unix :
```
aws rds describe-db-parameters --db-parameter-group-name default.aurora-postgresql12 \
--query 'Parameters[].[{ParameterName:ParameterName,Description:Description,ApplyType:ApplyType,AllowedValues:AllowedValues}]'
```
Pour Windows :
```
aws rds describe-db-parameters --db-parameter-group-name default.aurora-postgresql12 ^
--query "Parameters[].[{ParameterName:ParameterName,Description:Description,ApplyType:ApplyType,AllowedValues:AllowedValues}]"
```
Les commandes précédentes renvoient des listes de paramètres du cluster de bases de données ou du groupe de paramètres de base de données avec des descriptions et d’autres détails spécifiés dans la requête. Voici un exemple de réponse.
```
[
[
{
"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"
}
],...
```
Vous trouverez ci-dessous des tableaux contenant les valeurs du paramètre de cluster de bases de données par défaut et du paramètre de base de données pour Aurora PostgreSQL version 14.
## Paramètres de niveau cluster d’Aurora PostgreSQL
Vous pouvez consulter les paramètres au niveau du cluster disponibles pour une version spécifique d'Aurora PostgreSQL à l'aide de la AWS console de gestion, de la AWS CLI ou de l'API Amazon RDS. Pour obtenir des informations sur l’affichage des paramètres dans des groupes de paramètres de cluster de bases de données Aurora PostgreSQL dans la console RDS, consultez [Affichage des valeurs de paramètres pour un groupe de paramètres de cluster de base de données dans Amazon Aurora](USER_WorkingWithParamGroups.ViewingCluster.md).
Certains paramètres de niveau cluster ne sont pas disponibles dans toutes les versions et d’autres sont obsolètes. Pour obtenir des informations sur l’affichage des paramètres d’une version spécifique d’Aurora PostgreSQL, consultez [Affichage des paramètres de cluster de bases de données Aurora PostgreSQL et de base de données](#AuroraPostgreSQL.Reference.ParameterGroups-viewing-parameters).
Par exemple, le tableau suivant répertorie les paramètres disponibles dans le groupe de paramètres de cluster de bases de données par défaut pour Aurora PostgreSQL version 14. Si vous créez un cluster de bases de données Aurora PostgreSQL sans spécifier votre propre groupe de paramètres de base de données personnalisé, votre cluster de bases de données est créé à l’aide du groupe de paramètres de cluster de bases de données Aurora par défaut pour la version choisie, par exemple `default.aurora-postgresql14`, `default.aurora-postgresql13`, etc.
Pour obtenir une liste des paramètres d’instance de la base de données pour ce même groupe de paramètres de cluster de bases de données par défaut, consultez [Paramètres de niveau instance d’Aurora PostgreSQL](#AuroraPostgreSQL.Reference.Parameters.Instance).
| Nom du paramètre | Description | Par défaut |
| --- | --- | --- |
| ansi\$1constraint\$1trigger\$1ordering | Modifiez l’ordre de déclenchement des déclencheurs de contrainte pour qu’ils soient compatibles avec la norme ANSI SQL. | – |
| ansi\$1force\$1foreign\$1key\$1checks | Assurez-vous que les actions référentielles telles que la suppression en cascade ou la mise à jour en cascade se produisent toujours, quels que soient les contextes de déclencheur existants pour l’action. | – |
| ansi\$1qualified\$1update\$1set\$1target | Qualificateurs de table et de schéma de support dans les instructions UPDATE... SET. | – |
| apg\$1ccm\$1enabled | Activez ou désactivez la gestion des caches de clusters pour le cluster. | – |
| apg\$1enable\$1batch\$1mode\$1function\$1execution | Permet aux fonctions en mode traitement par lots de traiter plusieurs ensembles de lignes à la fois. | – |
| apg\$1enable\$1correlated\$1any\$1transform | Permet au planificateur de transformer le sous-lien ANY corrélé (sous-requête IN/NOT IN) en JOIN lorsque c’est possible. | – |
| apg\$1enable\$1function\$1migration | Permet au planificateur de migrer les fonctions scalaires éligibles vers la clause FROM. | – |
| apg\$1enable\$1not\$1in\$1transform | Permet au planificateur de transformer la sous-requête NOT IN en ANTI JOIN lorsque c’est possible. | – |
| apg\$1enable\$1remove\$1redundant\$1inner\$1joins | Permet au planificateur de supprimer les jointures internes redondantes. | – |
| apg\$1enable\$1semijoin\$1push\$1down | Permet l’utilisation de filtres de semi-jointure pour les jointures de hachage. | – |
| apg\$1plan\$1mgmt.capture\$1plan\$1baselines | Mode capture de référence de plans. manuel : active la capture de plans pour n’importe quelle instruction SQL, désactivé : désactive la capture de plans, automatique : active la capture de plans pour les instructions dans pg\$1stat\$1statements qui satisfont aux critères d’éligibilité. | off |
| apg\$1plan\$1mgmt.max\$1databases | Définit le nombre maximal de bases de données pouvant gérer des requêtes à l’aide de apg\$1plan\$1mgmt. | 10 |
| apg\$1plan\$1mgmt.max\$1plans | Définit le nombre maximal de plans pouvant être mis en cache par apg\$1plan\$1mgmt. | 10 000 |
| apg\$1plan\$1mgmt.plan\$1retention\$1period | Nombre maximal de jours écoulés depuis qu’un plan a été utilisé avant qu’un plan soit automatiquement supprimé. | 32 |
| apg\$1plan\$1mgmt.unapproved\$1plan\$1execution\$1threshold | Coût total estimé du plan en dessous duquel un plan non approuvé sera exécuté. | 0 |
| apg\$1plan\$1mgmt.use\$1plan\$1baselines | Utilisez uniquement des plans approuvés ou fixes pour les instructions gérées. | false |
| application\$1name | Définit le nom de l’application à indiquer dans les statistiques et les journaux. | – |
| array\$1nulls | Autorisez l’entrée d’éléments NULL dans les tableaux. | – |
| aurora\$1compute\$1plan\$1id | Surveille les plans d’exécution des requêtes pour détecter ceux qui contribuent à la charge actuelle de la base de données et pour suivre leurs statistiques de performance au fil du temps. Pour plus d’informations, consultez [Surveillance des plans d’exécution des requêtes pour Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraPostgreSQL.Monitoring.Query.Plans.html). | on |
| authentication\$1timeout | (s) Définit le délai maximum autorisé pour procéder à l’authentification du client. | – |
| auto\$1explain.log\$1analyze | Utilisez EXPLAIN ANALYZE pour la journalisation des plans. | – |
| auto\$1explain.log\$1buffers | Utilisation des tampons de journaux. | – |
| auto\$1explain.log\$1format | Format EXPLAIN à utiliser pour la journalisation des plans. | – |
| auto\$1explain.log\$1min\$1duration | Définit la durée minimum d’exécution au-delà de laquelle les plans seront journalisés. | – |
| auto\$1explain.log\$1nested\$1statements | Journalisez les instructions imbriquées. | – |
| auto\$1explain.log\$1timing | Collectez des données temporelles et non uniquement le nombre de lignes. | – |
| auto\$1explain.log\$1triggers | Incluez des statistiques de déclenchement dans les plans. | – |
| auto\$1explain.log\$1verbose | Utilisez EXPLAIN VERBOSE pour la journalisation des plans. | – |
| auto\$1explain.sample\$1rate | Partie de requêtes à traiter. | – |
| autovacuum | Démarre le sous-processus autovacuum. | – |
| autovacuum\$1analyze\$1scale\$1factor | Nombre d’insertions, de mises à jour ou de suppressions de tuples avant l’analyse en tant que partie de reltuples. | 0,05 |
| autovacuum\$1analyze\$1threshold | Nombre minimum d’insertions de tuples mis à jour ou supprimés avant l’analyse. | – |
| autovacuum\$1freeze\$1max\$1age | Âge auquel lancer le processus autovacuum sur une table pour empêcher le bouclage de l’ID de transaction. | – |
| autovacuum\$1max\$1workers | Définit le nombre maximum de processus de travail autovacuum qui peuvent être exécutés simultanément. | MEILLEUR (DBInstanceClassMemory/64371566592 ,3) |
| autovacuum\$1multixact\$1freeze\$1max\$1age | Âge multixact auquel lancer le processus autovacuum sur une table pour empêcher le processus multixact de bouclage. | – |
| autovacuum\$1naptime | (s) Temps de repos entre les exécutions autovacuum. | 5 |
| autovacuum\$1vacuum\$1cost\$1delay | (ms) Valeur du coût de retard du processus vacuum en millisecondes, pour le processus autovacuum. | 5 |
| autovacuum\$1vacuum\$1cost\$1limit | Coût cumulé qui provoque l’endormissement du processus vacuum, pour le processus autovacuum. | MEILLEUR (log (DBInstanceClassMemory/21474836480) \$1600 200) |
| autovacuum\$1vacuum\$1insert\$1scale\$1factor | Nombre d’insertions de tuples avant le processus vacuum en tant que partie de reltuples. | – |
| autovacuum\$1vacuum\$1insert\$1threshold | Nombre minimum d’insertions de tuples avant le processus vacuum ou -1 pour désactiver les insertions de vacuum. | – |
| autovacuum\$1vacuum\$1scale\$1factor | Nombre de tuples mis à jour ou supprimés avant le processus vacuum en tant que partie de reltuples. | 0.1 |
| autovacuum\$1vacuum\$1threshold | Nombre de tuples mis à jour ou supprimés avant le processus vacuum. | – |
| autovacuum\$1work\$1mem | (kB) Définit la quantité maximum de mémoire que peut utiliser chaque processus de travail autovacuum. | MEILLEUR (DBInstanceClassMemory/32768 ,131072) |
| babelfishpg\$1tds.default\$1server\$1name | Nom par défaut du serveur Babelfish | Microsoft SQL Server |
| babelfishpg\$1tds.listen\$1addresses | Définit le nom d’hôte ou les adresses IP sur lesquelles écouter TDS. | \$1 |
| babelfishpg\$1tds.port | Définit le port TCP TDS sur lequel le serveur écoute. | 1433 |
| babelfishpg\$1tds.tds\$1debug\$1log\$1level | Définit le niveau de journalisation dans TDS, 0 désactive la journalisation | 1 |
| babelfishpg\$1tds.tds\$1default\$1numeric\$1precision | Définit la précision par défaut du type numérique à envoyer dans les métadonnées de la colonne TDS si le moteur n’en spécifie pas. | 38 |
| babelfishpg\$1tds.tds\$1default\$1numeric\$1scale | Définit l’échelle par défaut du type numérique à envoyer dans les métadonnées de la colonne TDS si le moteur n’en spécifie pas. | 8 |
| babelfishpg\$1tds.tds\$1default\$1packet\$1size | Définit la taille par défaut des paquets pour tous les clients SQL Server connectés | 4096 |
| babelfishpg\$1tds.tds\$1default\$1protocol\$1version | Définit une version de protocole TDS par défaut pour tous les clients connectés | DEFAULT |
| babelfishpg\$1tds.tds\$1ssl\$1encrypt | Définit l’option de chiffrement SSL | 0 |
| babelfishpg\$1tds.tds\$1ssl\$1max\$1protocol\$1version | Définit la version maximale SSL/TLS du protocole à utiliser pour la session TDS. | TLSv12. |
| babelfishpg\$1tds.tds\$1ssl\$1min\$1protocol\$1version | Définit la version minimale SSL/TLS du protocole à utiliser pour la session TDS. | TLSv1.2 à partir d'Aurora PostgreSQL version 16 TLSv1 , pour les versions antérieures à Aurora PostgreSQL version 16 |
| babelfishpg\$1tsql.default\$1locale | Paramètres régionaux par défaut à utiliser pour les classements créés par CREATE COLLATION. | en-US |
| babelfishpg\$1tsql.migration\$1mode | Détermine si plusieurs bases de données utilisateur sont prises en charge. | multi-db à partir d’Aurora PostgreSQL 16, single-db pour les versions antérieures à Aurora PostgreSQL 16 |
| babelfishpg\$1tsql.server\$1collation\$1name | Nom du classement de serveur par défaut | sql\$1latin1\$1general\$1cp1\$1ci\$1as |
| babelfishpg\$1tsql.version | Définit la sortie de la variable @@VERSION | default |
| backend\$1flush\$1after | (8Kb) Nombre de pages après lesquelles les écritures précédemment effectuées sont vidées sur le disque. | – |
| backslash\$1quote | Définit si \$1\$1 peut être utilisée dans les littéraux de chaîne. | – |
| backtrace\$1functions | Enregistre le retour sur trace pour détecter les erreurs dans ces fonctions. | – |
| bytea\$1output | Définit le format de sortie pour les valeurs de type octets. | – |
| check\$1function\$1bodies | Vérifie les corps des fonctions pendant la fonction CREATE FUNCTION. | – |
| client\$1connection\$1check\$1interval | Définit l’intervalle de temps entre les vérifications de déconnexion lors de l’exécution des requêtes. | – |
| client\$1encoding | Définit l’encodage du jeu de caractères des clients. | UTF8 |
| client\$1min\$1messages | Définit les niveaux des messages envoyés au client. | – |
| compute\$1query\$1id | Calcule les identifiants de requêtes. | auto |
| config\$1file | Définit le fichier de configuration principal du serveur. | /rdsdbdata/config/postgresql.conf |
| constraint\$1exclusion | Autorise le planificateur à utiliser des contraintes pour optimiser les requêtes. | – |
| cpu\$1index\$1tuple\$1cost | Définit l’estimation faite par le planificateur du coût de traitement de chaque entrée d’index pendant la vérification d’un index. | – |
| cpu\$1operator\$1cost | Définit l’estimation faite par le planificateur du coût de traitement de chaque opérateur ou appel de fonction. | – |
| cpu\$1tuple\$1cost | Définit l’estimation faite par le planificateur du coût de traitement de chaque tuple (ligne). | – |
| cron.database\$1name | Définit la base de données pour stocker les tables de métadonnées pg\$1cron | postgres |
| cron.log\$1run | Journaliser toutes les exécutions de tâches dans la table job\$1run\$1details | on |
| cron.log\$1statement | Consignez toutes les instructions cron avant exécution. | off |
| cron.max\$1running\$1jobs | Nombre maximal de tâches pouvant être exécutées simultanément. | 5 |
| cron.use\$1background\$1workers | Active les applications de travail en arrière-plan pour pg\$1cron | on |
| cursor\$1tuple\$1fraction | Définit l’estimation faite par le planificateur de la fraction des lignes d’un curseur qui sera récupérée. | – |
| data\$1directory | Définit le répertoire de données du serveur. | /rdsdbdata/db |
| datestyle | Définit le format d’affichage des valeurs de type date et heure. | – |
| db\$1user\$1namespace | Active les noms d’utilisateurs par base de données. | – |
| deadlock\$1timeout | (ms) Définit le délai d’attente au niveau d’un verrou avant blocage. | – |
| debug\$1pretty\$1print | Indente les affichages des arborescences d’analyse et de planification. | – |
| debug\$1print\$1parse | Journalise l’arborescence d’analyse de chaque requête. | – |
| debug\$1print\$1plan | Journalise le plan d’exécution de chaque requête. | – |
| debug\$1print\$1rewritten | Journalise l’arbre d’interprétation réécrit de chaque requête. | – |
| default\$1statistics\$1target | Définit la cible des statistiques par défaut. | – |
| default\$1tablespace | Définit l’espace de table par défaut dans lequel créer des tables et des index. | – |
| default\$1toast\$1compression | Définit la méthode de compression par défaut pour les valeurs compressibles. | – |
| default\$1transaction\$1deferrable | Définit le statut reportable des nouvelles transactions. | – |
| default\$1transaction\$1isolation | Définit le niveau d’isolement de transaction de chaque nouvelle transaction. | – |
| default\$1transaction\$1read\$1only | Définit le statut en lecture seule des nouvelles transactions. | – |
| effective\$1cache\$1size | (8kB) Définit l’estimation faite par le planificateur de la taille du cache du disque. | SOMME (DBInstanceClassMemory/12038, -50003) |
| effective\$1io\$1concurrency | Nombre de demandes simultanées pouvant être traitées de manière efficace par le sous-système du disque. | – |
| enable\$1async\$1append | Active l’utilisation de plans d’ajout asynchrones par le planificateur. | – |
| enable\$1bitmapscan | Active l’utilisation de plans de parcours de bitmap par le planificateur. | – |
| enable\$1gathermerge | Active l’utilisation de plans de fusions de collecte par le planificateur. | – |
| enable\$1hashagg | Active l’utilisation de plans d’agrégation hachée par le planificateur. | – |
| enable\$1hashjoin | Active l’utilisation de plans de jointures de hachage par le planificateur. | – |
| enable\$1incremental\$1sort | Active l’utilisation d’étapes incrémentielles de tri par le planificateur. | – |
| enable\$1indexonlyscan | Permet aux planificateurs d'utiliser les index-only-scan plans. | – |
| enable\$1indexscan | Active l’utilisation de plans de parcours d’index par le planificateur. | – |
| enable\$1material | Active l’utilisation de la matérialisation par le planificateur. | – |
| enable\$1memoize | Active l’utilisation de la mémorisation par le planificateur. | – |
| enable\$1mergejoin | Active l’utilisation de plans de jointures de fusion par le planificateur. | – |
| enable\$1nestloop | Active l’utilisation de plans de jointures de boucles imbriquées par le planificateur. | – |
| enable\$1parallel\$1append | Active l’utilisation de plans d’ajout parallèles par le planificateur. | – |
| enable\$1parallel\$1hash | Active l’utilisation de plans de hachage parallèles par le planificateur. | – |
| enable\$1partition\$1pruning | Active l’élagage des partitions de planification et d’exécution. | – |
| enable\$1partitionwise\$1aggregate | Active l’agrégation et le regroupement entre partitions. | – |
| enable\$1partitionwise\$1join | Active la jointure entre partitions. | – |
| enable\$1seqscan | Active l’utilisation de plans de parcours séquentiels par le planificateur. | – |
| enable\$1sort | Active l’utilisation des étapes de tri explicite par le planificateur. | – |
| enable\$1tidscan | Active l’utilisation de plans de parcours de TID par le planificateur. | – |
| escape\$1string\$1warning | Avertit sur l’utilisation des barres obliques inverses dans des littéraux de chaîne ordinaires. | – |
| exit\$1on\$1error | Résilie la session en cas d’erreur. | – |
| extra\$1float\$1digits | Définit le nombre de chiffres affichés pour les valeurs à virgule flottante. | – |
| force\$1parallel\$1mode | Force l’utilisation d’installations de requêtes parallèles. | – |
| from\$1collapse\$1limit | Définit la taille FROM-list au-delà de laquelle les sous-requêtes ne sont pas regroupées. | – |
| geqo | Active l’optimisation génétique des requêtes. | – |
| geqo\$1effort | geqo\$1effort est utilisé pour définir la valeur par défaut pour les autres paramètres GEQO. | – |
| geqo\$1generations | GEQO : nombre d’itérations de l’algorithme. | – |
| geqo\$1pool\$1size | GEQO : nombre d’individus au sein d’une population. | – |
| geqo\$1seed | GEQO : valeur initiale pour la sélection des chemins au hasard. | – |
| geqo\$1selection\$1bias | GEQO : pression de sélectivité au sein de la population. | – |
| geqo\$1threshold | Définit le seuil d’éléments FROM au-delà duquel GEQO est utilisé. | – |
| gin\$1fuzzy\$1search\$1limit | Définit le résultat maximum autorisé pour la recherche exacte par GIN. | – |
| gin\$1pending\$1list\$1limit | (kB) Définit la taille maximale de la liste en attente pour l’index GIN. | – |
| hash\$1mem\$1multiplier | Multiple de work\$1mem à utiliser pour les tables de hachage. | – |
| hba\$1file | Définit le fichier de configuration hba du serveur. | /rdsdbdata/config/pg\$1hba.conf |
| hot\$1standby\$1feedback | Autorise le commentaire d’une instance de secours vers l’instance principale, ce qui évitera les conflits de requêtes. | on |
| huge\$1pages | Réduit la surcharge lorsqu’une instance de base de données fonctionne avec de gros morceaux de mémoire contigus, tels que ceux utilisés par les tampons partagés. Le paramètre est activé par défaut pour toutes les classes d’instance de base de données autres que les classes d’instance t3.medium, db.t3.large, db.t4g.medium, db.t4g.large. | on |
| ident\$1file | Définit le fichier de configuration ident du serveur. | /rdsdbdata/config/pg\$1ident.conf |
| idle\$1in\$1transaction\$1session\$1timeout | (ms) Définit la durée maximale de toute transaction inactive. | 86400000 |
| idle\$1session\$1timeout | Interrompt toute session qui est restée inactive (c’est-à-dire en attente d’une requête du client), mais qui ne figure pas dans le cadre d’une transaction ouverte, pendant plus longtemps que la durée spécifiée | – |
| intervalstyle | Définit le format d’affichage des valeurs de type intervalle. | – |
| join\$1collapse\$1limit | Définit la taille FROM-list au-delà de laquelle les constructions JOIN ne sont pas mises à plat. | – |
| krb\$1caseins\$1users | Définit si les noms d’utilisateur GSSAPI (Generic Security Service API) doivent être traités sans tenir compte de la casse (true) ou non. Par défaut, ce paramètre est défini sur false, de sorte que Kerberos s’attend à ce que les noms d’utilisateur soient sensibles à la casse. Pour plus d’informations, consultez [GSSAPI Authentication](https://www.postgresql.org/docs/current/gssapi-auth.html) (Authentification GSSAPI) dans la documentation de PostgreSQL. | false |
| lc\$1messages | Définit la langue d’affichage des messages. | – |
| lc\$1monetary | Définit la locale à utiliser pour le formatage des montants monétaires. | – |
| lc\$1numeric | Définit la locale à utiliser pour le formatage des nombres. | – |
| lc\$1time | Définit la locale à utiliser pour le formatage des valeurs de date et d’heure. | – |
| listen\$1addresses | Définit le nom d’hôte ou les adresses IP à écouter. | \$1 |
| lo\$1compat\$1privileges | Active le mode de compatibilité descendante pour les vérifications de privilèges sur de larges objets. | 0 |
| log\$1autovacuum\$1min\$1duration | (ms) Définit la durée minimum d’exécution au-delà de laquelle les actions autovacuum seront journalisées. | 10 000 |
| log\$1connections | Enregistre toutes les connexions réussies. | – |
| log\$1destination | Définit la destination pour la sortie du journal de serveur. | stderr |
| log\$1directory | Définit le répertoire de destination des fichiers journaux. | /rdsdbdata/log/error |
| log\$1disconnections | Enregistre la fin d’une session, y compris sa durée. | – |
| log\$1duration | Enregistre la durée de chaque instruction SQL terminée. | – |
| log\$1error\$1verbosity | Définit la quantité de détails dans les messages enregistrés. | – |
| log\$1executor\$1stats | Ecrit les statistiques de performance de l’exécuteur dans le journal du serveur. | – |
| log\$1file\$1mode | Définit les autorisations de fichier pour les fichiers journaux. | 0644 |
| log\$1filename | Définit le modèle de nom de fichier pour les fichiers journaux. | postgresql.log.%Y-%m-%d-%H%M |
| logging\$1collector | Démarrez un sous-processus pour capturer les fichiers and/or CSV de sortie stderr dans des fichiers journaux. | 1 |
| log\$1hostname | Enregistre le nom de l’hôte dans les journaux de connexion. | 0 |
| logical\$1decoding\$1work\$1mem | (kB) Cette quantité de mémoire peut être utilisée par chaque tampon interne de réorganisation avant le déversement sur le disque. | – |
| log\$1line\$1prefix | Contrôle les informations préfixées à chaque ligne de journal. | %t:%r:%u@%d:%p]: |
| log\$1lock\$1waits | Enregistre les longs temps d’attente pour l’acquisition d’un verrou. | – |
| log\$1min\$1duration\$1sample | (ms) Définit la durée minimum d’exécution au-delà de laquelle les instructions seront journalisées. L’échantillonnage est déterminé par log\$1statement\$1sample\$1rate. | – |
| log\$1min\$1duration\$1statement | (ms) Définit la durée minimum d’exécution au-delà de laquelle les instructions seront journalisées. | – |
| log\$1min\$1error\$1statement | Déclenche l’enregistrement de toutes les instructions générant une erreur à ce niveau ou à un niveau supérieur. | – |
| log\$1min\$1messages | Définit les niveaux des messages qui sont enregistrés. | – |
| log\$1parameter\$1max\$1length | (B) Lors de la journalisation des instructions, limitez les valeurs des paramètres enregistrés aux N premiers octets. | – |
| log\$1parameter\$1max\$1length\$1on\$1error | (B) Lorsque vous signalez une erreur, limitez les valeurs des paramètres enregistrés aux N premiers octets. | – |
| log\$1parser\$1stats | Ecrit les statistiques de performance de l’analyseur dans le journal du serveur. | – |
| log\$1planner\$1stats | Ecrit les statistiques de performance du planificateur dans le journal du serveur. | – |
| log\$1replication\$1commands | Journalise chaque commande de réplication. | – |
| log\$1rotation\$1age | (min) Déclenchement de la rotation de fichier journal automatique au-delà d’un délai de N minutes. | 60 |
| log\$1rotation\$1size | (kB) Déclenchement de la rotation de fichier journal automatique au-delà de N kilo-octets. | 100 000 |
| log\$1statement | Définit le type d’instructions enregistrées. | – |
| log\$1statement\$1sample\$1rate | Partie d’instructions dépassant log\$1min\$1duration\$1sample à journaliser. | – |
| log\$1statement\$1stats | Ecrit les statistiques de performance cumulées dans le journal du serveur. | – |
| log\$1temp\$1files | (kB) Journalise l’utilisation des fichiers temporaires dont la taille est supérieure à cette taille en kilo-octets. | – |
| log\$1timezone | Définit le fuseau horaire à utiliser dans les messages de journaux. | UTC |
| log\$1transaction\$1sample\$1rate | Définissez la partie des transactions à journaliser pour les nouvelles transactions. | – |
| log\$1truncate\$1on\$1rotation | Tronquez les fichiers journaux existants du même nom pendant la rotation des journaux. | 0 |
| maintenance\$1io\$1concurrency | Variante de effective\$1io\$1concurrency utilisée pour les tâches de maintenance. | 1 |
| maintenance\$1work\$1mem | (kB) Définit la quantité maximum de mémoire que peuvent utiliser les opérations de maintenance. | MEILLEUR (DBInstanceClassMemory/63963136 \$11024,65536) |
| max\$1connections | Définit le nombre maximum de connexions simultanées. | AU MOINS (DBInstanceClassMemory/9531392 5000) |
| max\$1files\$1per\$1process | Définit le nombre maximum de fichiers ouverts simultanément pour chaque processus serveur. | – |
| max\$1locks\$1per\$1transaction | Définit le nombre maximum de verrous par transaction. | 64 |
| max\$1logical\$1replication\$1workers | Nombre maximal de processus de travail de réplication logique. | – |
| max\$1parallel\$1maintenance\$1workers | Définit le nombre maximal de processus parallèles par opération de maintenance. | – |
| max\$1parallel\$1workers | Définit le nombre maximal d’applications de travail parallèles pouvant être actives simultanément. | MEILLEUR (\$1 DBInstance VCPU/2,8) |
| max\$1parallel\$1workers\$1per\$1gather | Définit le nombre maximal de processus parallèles par nœud d’exécuteur. | – |
| max\$1pred\$1locks\$1per\$1page | Définit le nombre maximal de tuples verrouillés par prédicat par page. | – |
| max\$1pred\$1locks\$1per\$1relation | Définit le nombre maximum de pages et de tuples verrouillés par prédicat par relation. | – |
| max\$1pred\$1locks\$1per\$1transaction | Définit le nombre maximum de verrous de prédicat par transaction. | – |
| max\$1prepared\$1transactions | Définit le nombre maximum de transactions préparées simultanément. | 0 |
| max\$1replication\$1slots | Définit le nombre maximum d’emplacements de réplication que le serveur peut prendre en charge. | 20 |
| max\$1slot\$1wal\$1keep\$1size | (MB) Les emplacements de réplication seront marqués comme ayant échoué et les segments seront libérés pour suppression ou recyclage si cette quantité d’espace est occupée par WAL sur le disque. | – |
| max\$1stack\$1depth | (kB) Définit la profondeur maximum de la pile, en kilo-octets. | 6144 |
| max\$1standby\$1streaming\$1delay | (ms) Définit le délai maximum avant l’annulation des requêtes lorsqu’un serveur de secours traite des données WAL diffusées. | 14000 |
| max\$1sync\$1workers\$1per\$1subscription | Nombre maximum d’applications de travail de synchronisation par abonnement | 2 |
| max\$1wal\$1senders | Définit le nombre maximum de processus d’expéditeur WAL qui peuvent être exécutés simultanément. | 10 |
| max\$1worker\$1processes | Définit le nombre maximum de processus de travail simultanés. | MEILLEUR (\$1 DBInstance VCPU\$12,8) |
| min\$1dynamic\$1shared\$1memory | (Mo) Quantité de mémoire partagée dynamique réservée au démarrage. | – |
| min\$1parallel\$1index\$1scan\$1size | (8kB) Définit la quantité minimum de données d’index pour une analyse parallèle. | – |
| min\$1parallel\$1table\$1scan\$1size | (8kB) Définit la quantité minimum de données de table pour une analyse parallèle. | – |
| old\$1snapshot\$1threshold | (min) Délai avant qu’un instantané soit trop ancien pour lire les pages modifiées après la prise de l’instantané. | – |
| orafce.nls\$1date\$1format | Émule le comportement de sortie des données d’Oracle. | – |
| orafce.timezone | Spécifie le fuseau horaire utilisé pour la fonction sysdate. | – |
| parallel\$1leader\$1participation | Contrôle si Gather et Gather Merge exécutent également des sous-plans. | – |
| parallel\$1setup\$1cost | Définit l’estimation du planificateur du coût de démarrage des processus de travail pour les requêtes parallèles. | – |
| parallel\$1tuple\$1cost | Définit l’estimation du planificateur du coût de transmission de chaque tuple (ligne) de l’application de travail vers le système dorsal principal. | – |
| password\$1encryption | Chiffrez les mots de passe. | – |
| pgaudit.log | Spécifie quelles classes d’instructions seront journalisées par la journalisation de l’audit de session. | – |
| pgaudit.log\$1catalog | Spécifie que la journalisation de session doit être activée dans le cas où toutes les relations d’une instruction se trouvent dans pg\$1catalog. | – |
| pgaudit.log\$1level | Spécifie le niveau de journal qui sera utilisé pour les entrées de journal. | – |
| pgaudit.log\$1parameter | Spécifie que la journalisation de l’audit doit inclure les paramètres transmis avec l’instruction. | – |
| pgaudit.log\$1relation | Spécifie si la journalisation de l’audit de session doit créer une entrée de journal distincte pour chaque relation (TABLE, VIEW, etc.) référencée dans une instruction SELECT ou DML. | – |
| pgaudit.log\$1statement\$1once | Spécifie si la journalisation inclura le texte de l'instruction et les paramètres avec la première entrée de journal d'une statement/substatement combinaison ou avec chaque entrée. | – |
| pgaudit.role | Spécifie le rôle principal à utiliser pour la journalisation de l’audit des objets. | – |
| pg\$1bigm.enable\$1recheck | Spécifie s’il faut effectuer une revérification qui est un processus interne de recherche en texte intégral. | on |
| pg\$1bigm.gin\$1key\$1limit | Spécifie le nombre maximum de 2 grammes du mot-clé de recherche à utiliser pour la recherche en texte intégral. | 0 |
| pg\$1bigm.last\$1update | Indique la dernière date de mise à jour du module pg\$1bigm. | 2013.11.22 |
| pg\$1bigm.similarity\$1limit | Spécifie le seuil minimal utilisé par la recherche de similarité. | 0.3 |
| pg\$1hint\$1plan.debug\$1print | Journalise les résultats de l’analyse des indices. | – |
| pg\$1hint\$1plan.enable\$1hint | Force le planificateur à utiliser les plans spécifiés dans le commentaire d’indice précédant la requête. | – |
| pg\$1hint\$1plan.enable\$1hint\$1table | Force le planificateur à ne pas obtenir d’indice à l’aide des recherches de table. | – |
| pg\$1hint\$1plan.message\$1level | Niveau de message des messages de débogage. | – |
| pg\$1hint\$1plan.parse\$1messages | Niveau de message des erreurs d’analyse. | – |
| pglogical.batch\$1inserts | Insertions de lots si possible | – |
| pglogical.conflict\$1log\$1level | Définit le niveau de journal utilisé pour la journalisation des conflits résolus. | – |
| pglogical.conflict\$1resolution | Définit la méthode utilisée pour la résolution des conflits résolubles. | – |
| pglogical.extra\$1connection\$1options | options de connexion à ajouter à toutes les connexions de nœuds de pairs | – |
| pglogical.synchronous\$1commit | valeur de validation synchrone spécifique pglogical | – |
| pglogical.use\$1spi | Utiliser une SPI au lieu d’une API de bas niveau pour appliquer les modifications | – |
| pgtle.clientauth\$1databases\$1to\$1skip | Liste des bases de données à ignorer pour la fonctionnalité clientauth. | – |
| pgtle.clientauth\$1db\$1name | Contrôle la base de données utilisée pour la fonctionnalité clientauth. | – |
| pgtle.clientauth\$1num\$1parallel\$1workers | Nombre d’applications de travail en arrière-plan utilisés pour la fonctionnalité clientauth. | – |
| pgtle.clientauth\$1users\$1to\$1skip | Liste des utilisateurs à ignorer pour la fonctionnalité clientauth. | – |
| pgtle.enable\$1clientauth | Active la fonctionnalité clientauth. | – |
| pgtle.passcheck\$1db\$1name | Définit la base de données utilisée pour la fonctionnalité de vérification de mot de passe à l’échelle du cluster. | – |
| pg\$1prewarm.autoprewarm | Démarre l’application de travail autoprewarm. | – |
| pg\$1prewarm.autoprewarm\$1interval | Définit l’intervalle entre les vidages de tampons partagés | – |
| pg\$1similarity.block\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.block\$1threshold | Définit le seuil utilisé par la fonction de similarité Block. | – |
| pg\$1similarity.block\$1tokenizer | Définit le créateur de jetons pour la fonction de similarité Block. | – |
| pg\$1similarity.cosine\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.cosine\$1threshold | Définit le seuil utilisé par la fonction de similarité Cosine. | – |
| pg\$1similarity.cosine\$1tokenizer | Définit le créateur de jetons pour la fonction de similarité Cosine. | – |
| pg\$1similarity.dice\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.dice\$1threshold | Définit le seuil utilisé par la mesure de similarité Dice. | – |
| pg\$1similarity.dice\$1tokenizer | Définit le créateur de jetons pour la mesure de similarité Dice. | – |
| pg\$1similarity.euclidean\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.euclidean\$1threshold | Définit le seuil utilisé par la mesure de similarité Euclidean. | – |
| pg\$1similarity.euclidean\$1tokenizer | Définit le créateur de jetons pour la mesure de similarité Euclidean. | – |
| pg\$1similarity.hamming\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.hamming\$1threshold | Définit le seuil utilisé par la mesure de similarité Block. | – |
| pg\$1similarity.jaccard\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.jaccard\$1threshold | Définit le seuil utilisé par la mesure de similarité Jaccard. | – |
| pg\$1similarity.jaccard\$1tokenizer | Définit le créateur de jetons pour la mesure de similarité Jaccard. | – |
| pg\$1similarity.jaro\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.jaro\$1threshold | Définit le seuil utilisé par la mesure de similarité Jaro. | – |
| pg\$1similarity.jarowinkler\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.jarowinkler\$1threshold | Définit le seuil utilisé par la mesure de similarité Jarowinkler. | – |
| pg\$1similarity.levenshtein\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.levenshtein\$1threshold | Définit le seuil utilisé par la mesure de similarité Levenshtein. | – |
| pg\$1similarity.matching\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.matching\$1threshold | Définit le seuil utilisé par la mesure de similarité Matching Coefficient. | – |
| pg\$1similarity.matching\$1tokenizer | Définit le créateur de jetons pour la mesure de similarité Matching Coefficient. | – |
| pg\$1similarity.mongeelkan\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.mongeelkan\$1threshold | Définit le seuil utilisé par la mesure de similarité Monge-Elkan. | – |
| pg\$1similarity.mongeelkan\$1tokenizer | Définit le créateur de jetons pour la mesure de similarité Monge-Elkan. | – |
| pg\$1similarity.nw\$1gap\$1penalty | Définit la pénalité d’écart utilisée par la mesure de similarité Needleman-Wunsch. | – |
| pg\$1similarity.nw\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.nw\$1threshold | Définit le seuil utilisé par la mesure de similarité Needleman-Wunsch. | – |
| pg\$1similarity.overlap\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.overlap\$1threshold | Définit le seuil utilisé par la mesure de similarité Overlap Coefficient. | – |
| pg\$1similarity.overlap\$1tokenizer | Définit le créateur de jetons pour la mesure de similarité Overlap Coefficient. | – |
| pg\$1similarity.qgram\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.qgram\$1threshold | Définit le seuil utilisé par la mesure de similarité Q-Gram. | – |
| pg\$1similarity.qgram\$1tokenizer | Définit le créateur de jetons pour la mesure Q-Gram. | – |
| pg\$1similarity.swg\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.swg\$1threshold | Définit le seuil utilisé par la mesure de Smith-Waterman-Gotoh similarité. | – |
| pg\$1similarity.sw\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.sw\$1threshold | Définit le seuil utilisé par la mesure de similarité Smith-Waterman. | – |
| pg\$1stat\$1statements.max | Définit le nombre maximal d’instructions suivies par pg\$1stat\$1statements. | – |
| pg\$1stat\$1statements.save | Enregistre les statistiques pg\$1stat\$1statements sur les arrêts de serveur. | – |
| pg\$1stat\$1statements.track | Définit les instructions qui sont suivies par pg\$1stat\$1statements. | – |
| pg\$1stat\$1statements.track\$1planning | Définit si le délai de planification est suivi par pg\$1stat\$1statements. | – |
| pg\$1stat\$1statements.track\$1utility | Définit si les commandes d’utilitaire sont suivies par pg\$1stat\$1statements. | – |
| plan\$1cache\$1mode | Contrôle la sélection du planificateur d’un plan personnalisé ou générique. | – |
| port | Définit le port TCP sur lequel le serveur écoute. | EndPointPort |
| postgis.gdal\$1enabled\$1drivers | Activez ou désactivez les pilotes GDAL utilisés avec PostGIS dans Postgres 9.3.5 et versions ultérieures. | ENABLE\$1ALL |
| quote\$1all\$1identifiers | Lors de la génération de fragments SQL, ajoute des guillemets à tous les identifiants. | – |
| random\$1page\$1cost | Définit l’estimation faite par le planificateur du coût d’une page de disque extraite de façon non séquentielle. | – |
| rdkit.dice\$1threshold | Seuil inférieur de similarité Dice. Les molécules dont la similarité est inférieure au seuil ne sont pas similaires par l’opération \$1. | – |
| rdkit.do\$1chiral\$1sss | Si la stéréochimie doit être prise en compte dans la correspondance des sous-structures. Si la valeur est fausse, aucune information de stéréochimie n’est utilisée dans les correspondances des sous-structures. | – |
| rdkit.tanimoto\$1threshold | Seuil inférieur de similitude avec Tanimoto. Les molécules dont la similarité est inférieure au seuil ne sont pas similaires par l’opération %. | – |
| rds.accepted\$1password\$1auth\$1method | Force l’authentification des connexions avec un mot de passe stocké localement. | md5\$1scram |
| rds.adaptive\$1autovacuum | Paramètre RDS pour l'autovacuum enable/disable adaptatif. | 1 |
| rds.babelfish\$1status | Paramètre RDS pour enable/disable Babelfish pour Aurora PostgreSQL. | off |
| rds.enable\$1plan\$1management | Activez ou désactivez l’extension apg\$1plan\$1mgmt. | 0 |
| rds.extensions | Liste des extensions fournies par RDS | address\$1standardizer, address\$1standardizer\$1data\$1us, apg\$1plan\$1mgmt, aurora\$1stat\$1utils, amcheck, autoinc, aws\$1commons, aws\$1ml, aws\$1s3, aws\$1lambda, bool\$1plperl, bloom, btree\$1gin, btree\$1gist, citext, cube, dblink, dict\$1int, dict\$1xsyn, earthdistance, fuzzystrmatch, hll, hstore, hstore\$1plperl, insert\$1username, intagg, intarray, ip4r, isn, jsonb\$1plperl, lo, log\$1fdw, ltree, moddatetime, old\$1snapshot, oracle\$1fdw, orafce, pgaudit, pgcrypto, pglogical, pgrouting, pgrowlocks, pgstattuple, pgtap, pg\$1bigm, pg\$1buffercache, pg\$1cron, pg\$1freespacemap, pg\$1hint\$1plan, pg\$1partman, pg\$1prewarm, pg\$1proctab, pg\$1repack, pg\$1similarity, pg\$1stat\$1statements, pg\$1trgm, pg\$1visibility, plcoffee, plls, plperl, plpgsql, plprofiler, pltcl, plv8, postgis, postgis\$1tiger\$1geocoder, postgis\$1raster, postgis\$1topology, postgres\$1fdw, prefix, rdkit, rds\$1tools, refint, sslinfo, tablefunc, tds\$1fdw, test\$1parser, tsm\$1system\$1rows, tsm\$1system\$1time, unaccent, uuid-ossp |
| rds.force\$1admin\$1logging\$1level | Consultez les messages de journalisation des actions d’utilisateur de l’administrateur RDS dans les bases de données clients. | – |
| rds.force\$1autovacuum\$1logging\$1level | Consultez les messages de journal relatifs aux opérations d’autovacuum. | WARNING |
| rds.force\$1ssl | Forcez les connexions SSL. | 0 |
| rds.global\$1db\$1rpo | (s) Seuil d’objectif de point de reprise en secondes qui bloque les validations de l’utilisateur lorsqu’il est violé. Ce paramètre est destiné aux bases de données globales basées sur Aurora PostgreSQL. Pour une base de données non globale, conservez la valeur par défaut. Pour en savoir plus sur l’utilisation de ce paramètre, consultez [Gestion des RPO pour les bases de données globales basées sur Aurora PostgreSQL–](aurora-global-database-disaster-recovery.md#aurora-global-database-manage-recovery). | – |
| rds.logical\$1replication | Active le décodage logique. | 0 |
| rds.logically\$1replicate\$1unlogged\$1tables | Les tables non journalisées sont répliquées de manière logique. | 1 |
| rds.log\$1retention\$1period | Amazon RDS supprimera les journaux PostgreSQL antérieurs à N minutes. | 4320 |
| rds.pg\$1stat\$1ramdisk\$1size | Taille du disque RAM des statistiques en Mo. Une valeur différente de zéro va configurer le disque RAM. Ce paramètre est disponible uniquement dans Aurora PostgreSQL 14 et les versions antérieures. | 0 |
| rds.rds\$1superuser\$1reserved\$1connections | Définit le nombre d’emplacements de connexion réservés pour rds\$1superusers. Ce paramètre est uniquement disponible dans les versions 15 et antérieures. Pour plus d’informations, consultez la documentation de PostgreSQL sur [reserved\$1connections](https://www.postgresql.org/docs/current/runtime-config-connection.html#GUC-RESERVED-CONNECTIONS). | 2 |
| rds.restrict\$1password\$1commands | restreint les commandes liées au mot de passe aux membres de rds\$1password | – |
| rds.superuser\$1variables | Liste des variables réservées aux super-utilisateurs pour lesquelles nous augmentons les instructions de modification rds\$1superuser. | session\$1replication\$1role |
| recovery\$1init\$1sync\$1method | Définit la méthode de synchronisation du répertoire de données avant la reprise après incident. | syncfs |
| remove\$1temp\$1files\$1after\$1crash | Supprime les fichiers temporaires après l’arrêt du système dorsal. | 0 |
| restart\$1after\$1crash | Réinitialisez le serveur après l’arrêt du système dorsal. | – |
| row\$1security | Activez la sécurité au niveau des lignes. | – |
| search\$1path | Définit l’ordre de recherche des schémas pour les noms pour lesquels le schéma n’est pas précisé. | – |
| seq\$1page\$1cost | Définit l’estimation faite par le planificateur du coût d’une page de disque extraite de façon séquentielle. | – |
| session\$1replication\$1role | Définit le comportement des sessions concernant les déclencheurs et les règles de réécriture. | – |
| shared\$1buffers | (8kB) Définit le nombre de tampons de mémoire partagée utilisés par le serveur. | SOMME (DBInstanceClassMemory/12038, -50003) |
| shared\$1preload\$1libraries | Répertorie les bibliothèques partagées à précharger sur le serveur. | pg\$1stat\$1statements |
| ssl | Active les connexions SSL. | 1 |
| ssl\$1ca\$1file | Emplacement du fichier d’autorité du serveur SSL. | /rdsdbdata/rds-metadata/ca-cert.pem |
| ssl\$1cert\$1file | Emplacement du fichier de certificat du serveur SSL. | /rdsdbdata/rds-metadata/server-cert.pem |
| ssl\$1ciphers | Définit la liste des chiffrements TLS autorisés à utiliser sur les connexions sécurisées. | – |
| ssl\$1crl\$1dir | Emplacement du répertoire de la liste de révocation des certificats SSL. | /rdsdbdata/rds-metadata/ssl\$1crl\$1dir/ |
| ssl\$1key\$1file | Emplacement du fichier de clé privée du serveur SSL | /rdsdbdata/rds-metadata/server-key.pem |
| ssl\$1max\$1protocol\$1version | Définit la version maximale SSL/TLS du protocole autorisée | – |
| ssl\$1min\$1protocol\$1version | Définit la version minimale SSL/TLS du protocole autorisée | TLSv12. |
| standard\$1conforming\$1strings | Entraîne les chaînes ... à traiter littéralement les barres obliques inverses. | – |
| statement\$1timeout | (ms) Définit la durée maximum de toute instruction. | – |
| stats\$1temp\$1directory | Écrit des fichiers de statistiques temporaires dans le répertoire spécifié. | /rdsdbdata/db/pg\$1stat\$1tmp |
| superuser\$1reserved\$1connections | Définit le nombre d’emplacements de connexion réservés aux super-utilisateurs. | 3 |
| synchronize\$1seqscans | Active les analyses séquentielles synchronisées. | – |
| synchronous\$1commit | Définit le niveau de synchronisation des transactions actuelles. | on |
| tcp\$1keepalives\$1count | Nombre maximum de paquets TCP keepalive. | – |
| tcp\$1keepalives\$1idle | (s) Délai entre les émissions de paquets TCP keepalive. | – |
| tcp\$1keepalives\$1interval | (s) Délai entre les envois de paquets TCP keepalive. | – |
| temp\$1buffers | (8kB) Définit le nombre maximum de tampons temporaires utilisés par chaque session. | – |
| temp\$1file\$1limit | Contraint l’espace disque total en kilo-octets qu’un processus PostgreSQL donné peut utiliser pour les fichiers temporaires, à l’exclusion de l’espace utilisé pour les tables temporaires explicites | -1 |
| temp\$1tablespaces | Définit les espaces de table à utiliser pour les tables et fichiers de tri temporaires. | – |
| timezone | Définit le fuseau horaire pour l’affichage et l’interprétation de la date et de l’heure. | UTC |
| track\$1activities | Active la collecte d’informations sur l’exécution des commandes. | – |
| track\$1activity\$1query\$1size | Définit la taille réservée pour pg\$1stat\$1activity.current\$1query, en octets. | 4096 |
| track\$1commit\$1timestamp | Collecte l’heure de validation des transactions. | – |
| track\$1counts | Active la collecte de statistiques sur l’activité de la base de données. | – |
| track\$1functions | Active la collecte de statistiques au niveau de la fonction sur l’activité de la base de données. | pl |
| track\$1io\$1timing | Active la collecte de statistiques de durée sur l’activité I/O de la base de données. | 1 |
| track\$1wal\$1io\$1timing | Collecte des statistiques de durée sur l’activité I/O de WAL. | – |
| transform\$1null\$1equals | Traite l’expression =NULL en tant que IS NULL. | – |
| update\$1process\$1title | Met à jour le titre du processus pour indiquer la commande SQL active. | – |
| vacuum\$1cost\$1delay | (ms) Valeur du coût de délai du processus vacuum en millisecondes. | – |
| vacuum\$1cost\$1limit | Coût cumulé qui provoque l’endormissement du processus vacuum. | – |
| vacuum\$1cost\$1page\$1dirty | Coût du processus vacuum pour une page salie par le processus vacuum. | – |
| vacuum\$1cost\$1page\$1hit | Coût du processus vacuum pour une page trouvée dans le cache des tampons. | – |
| vacuum\$1cost\$1page\$1miss | Coût du processus vacuum pour une page non trouvée dans le cache des tampons. | 0 |
| vacuum\$1defer\$1cleanup\$1age | Nombre de transactions pendant lesquelles le processus VACUUM et le nettoyage HOT seront reportés à plus tard, le cas échéant. | – |
| vacuum\$1failsafe\$1age | Âge auquel le processus VACUUM doit déclencher la sécurité pour éviter une panne complète. | 1200000000 |
| vacuum\$1freeze\$1min\$1age | Âge limite auquel le processus VACUUM doit figer une ligne de tableau. | – |
| vacuum\$1freeze\$1table\$1age | Âge auquel le processus VACUUM effectue une analyse complète de la table pour figer des lignes. | – |
| vacuum\$1multixact\$1failsafe\$1age | Âge Multixact auquel le processus VACUUM doit déclencher la sécurité pour éviter une panne complète. | 1200000000 |
| vacuum\$1multixact\$1freeze\$1min\$1age | Âge minimum auquel VACUUM doit congeler a MultiXactId dans une rangée du tableau. | – |
| vacuum\$1multixact\$1freeze\$1table\$1age | Âge Multixact auquel le processus VACUUM effectue une analyse complète de la table pour figer des lignes. | – |
| wal\$1buffers | (8kB) Définit le nombre de tampons de page de disque dans la mémoire partagée pour WAL. | – |
| wal\$1receiver\$1create\$1temp\$1slot | Définit si un récepteur WAL doit créer un emplacement de réplication temporaire lorsqu’aucun emplacement permanent n’est configuré. | 0 |
| wal\$1receiver\$1status\$1interval | (s) Définit l’intervalle maximal entre les rapports d’état du récepteur WAL et le principal. | – |
| wal\$1receiver\$1timeout | (ms) Définit le délai d’attente maximal pour recevoir les données du principal. | 30 000 |
| wal\$1sender\$1timeout | (ms) Définit le délai d’attente maximal de la réplication WAL. | – |
| work\$1mem | (kB) Définit la quantité maximum de mémoire que peuvent utiliser les espaces de travail des requêtes. | – |
| xmlbinary | Définit la façon dont les valeurs binaires doivent être codées en XML. | – |
| xmloption | Définit si des données XML dans des opérations d’analyse ou de sérialisation implicites doivent être considérées comme des documents ou des fragments de contenu. | – |
## Paramètres de niveau instance d’Aurora PostgreSQL
Vous pouvez consulter les paramètres au niveau de l'instance disponibles pour une version spécifique d'Aurora PostgreSQL à l'aide de la AWS console de gestion, de la CLI ou de l'API Amazon AWS RDS. Pour obtenir des informations sur l’affichage des paramètres dans des groupes de paramètres de base de données Aurora PostgreSQL dans la console RDS, consultez [Affichage des valeurs de paramètres pour un groupe de paramètres de base de données dans Amazon Aurora](USER_WorkingWithParamGroups.Viewing.md).
Certains paramètres de niveau d’instance ne sont pas disponibles dans toutes les versions et d’autres sont obsolètes. Pour obtenir des informations sur l’affichage des paramètres d’une version spécifique d’Aurora PostgreSQL, consultez [Affichage des paramètres de cluster de bases de données Aurora PostgreSQL et de base de données](#AuroraPostgreSQL.Reference.ParameterGroups-viewing-parameters).
Par exemple, le tableau suivant répertorie les paramètres qui s’appliquent à une instance de base de données spécifique dans un cluster de bases de données Aurora PostgreSQL. Cette liste a été générée en exécutant la [describe-db-parameters](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-parameters.html) AWS CLI commande avec `default.aurora-postgresql14` pour `--db-parameter-group-name` valeur.
Pour obtenir une liste des paramètres de cluster de bases de données pour ce même groupe de paramètres de base de données par défaut, consultez [Paramètres de niveau cluster d’Aurora PostgreSQL](#AuroraPostgreSQL.Reference.Parameters.Cluster).
| Nom du paramètre | Description | Par défaut |
| --- | --- | --- |
| apg\$1enable\$1batch\$1mode\$1function\$1execution | Permet aux fonctions en mode traitement par lots de traiter plusieurs ensembles de lignes à la fois. | – |
| apg\$1enable\$1correlated\$1any\$1transform | Permet au planificateur de transformer le sous-lien ANY corrélé (sous-requête IN/NOT IN) en JOIN lorsque c’est possible. | – |
| apg\$1enable\$1function\$1migration | Permet au planificateur de migrer les fonctions scalaires éligibles vers la clause FROM. | – |
| apg\$1enable\$1not\$1in\$1transform | Permet au planificateur de transformer la sous-requête NOT IN en ANTI JOIN lorsque c’est possible. | – |
| apg\$1enable\$1remove\$1redundant\$1inner\$1joins | Permet au planificateur de supprimer les jointures internes redondantes. | – |
| apg\$1enable\$1semijoin\$1push\$1down | Permet l’utilisation de filtres de semi-jointure pour les jointures de hachage. | – |
| apg\$1plan\$1mgmt.capture\$1plan\$1baselines | Mode capture de référence de plans. manuel : active la capture de plans pour n’importe quelle instruction SQL, désactivé : désactive la capture de plans, automatique : active la capture de plans pour les instructions dans pg\$1stat\$1statements qui satisfont aux critères d’éligibilité. | off |
| apg\$1plan\$1mgmt.max\$1databases | Définit le nombre maximal de bases de données pouvant gérer des requêtes à l’aide de apg\$1plan\$1mgmt. | 10 |
| apg\$1plan\$1mgmt.max\$1plans | Définit le nombre maximal de plans pouvant être mis en cache par apg\$1plan\$1mgmt. | 10 000 |
| apg\$1plan\$1mgmt.plan\$1retention\$1period | Nombre maximal de jours écoulés depuis qu’un plan a été utilisé avant qu’un plan soit automatiquement supprimé. | 32 |
| apg\$1plan\$1mgmt.unapproved\$1plan\$1execution\$1threshold | Coût total estimé du plan en dessous duquel un plan non approuvé sera exécuté. | 0 |
| apg\$1plan\$1mgmt.use\$1plan\$1baselines | Utilisez uniquement des plans approuvés ou fixes pour les instructions gérées. | false |
| application\$1name | Définit le nom de l’application à indiquer dans les statistiques et les journaux. | – |
| aurora\$1compute\$1plan\$1id | Surveille les plans d’exécution des requêtes pour détecter ceux qui contribuent à la charge actuelle de la base de données et pour suivre leurs statistiques de performance au fil du temps. Pour plus d’informations, consultez [Surveillance des plans d’exécution des requêtes pour Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraPostgreSQL.Monitoring.Query.Plans.html). | on |
| aurora\$1temp\$1space\$1size | (Mo) Définit la taille de l’espace alloué aux objets temporaires compatibles avec Optimized Reads sur les clusters optimisés pour les E/S Aurora avec les classes d’instance prises en charge. | DBInstanceClassMemory/524288 |
| authentication\$1timeout | (s) Définit le délai maximum autorisé pour procéder à l’authentification du client. | – |
| auto\$1explain.log\$1analyze | Utilisez EXPLAIN ANALYZE pour la journalisation des plans. | – |
| auto\$1explain.log\$1buffers | Utilisation des tampons de journaux. | – |
| auto\$1explain.log\$1format | Format EXPLAIN à utiliser pour la journalisation des plans. | – |
| auto\$1explain.log\$1min\$1duration | Définit la durée minimum d’exécution au-delà de laquelle les plans seront journalisés. | – |
| auto\$1explain.log\$1nested\$1statements | Journalisez les instructions imbriquées. | – |
| auto\$1explain.log\$1timing | Collectez des données temporelles et non uniquement le nombre de lignes. | – |
| auto\$1explain.log\$1triggers | Incluez des statistiques de déclenchement dans les plans. | – |
| auto\$1explain.log\$1verbose | Utilisez EXPLAIN VERBOSE pour la journalisation des plans. | – |
| auto\$1explain.sample\$1rate | Partie de requêtes à traiter. | – |
| babelfishpg\$1tds.listen\$1addresses | Définit le nom d’hôte ou les adresses IP sur lesquelles écouter TDS. | \$1 |
| babelfishpg\$1tds.tds\$1debug\$1log\$1level | Définit le niveau de journalisation dans TDS, 0 désactive la journalisation | 1 |
| backend\$1flush\$1after | (8kB) Nombre de pages après lesquelles les écritures précédemment effectuées sont vidées sur le disque. | – |
| bytea\$1output | Définit le format de sortie pour les valeurs de type octets. | – |
| check\$1function\$1bodies | Vérifie les corps des fonctions pendant la fonction CREATE FUNCTION. | – |
| client\$1connection\$1check\$1interval | Définit l’intervalle de temps entre les vérifications de déconnexion lors de l’exécution des requêtes. | – |
| client\$1min\$1messages | Définit les niveaux des messages envoyés au client. | – |
| config\$1file | Définit le fichier de configuration principal du serveur. | /rdsdbdata/config/postgresql.conf |
| constraint\$1exclusion | Autorise le planificateur à utiliser des contraintes pour optimiser les requêtes. | – |
| cpu\$1index\$1tuple\$1cost | Définit l’estimation faite par le planificateur du coût de traitement de chaque entrée d’index pendant la vérification d’un index. | – |
| cpu\$1operator\$1cost | Définit l’estimation faite par le planificateur du coût de traitement de chaque opérateur ou appel de fonction. | – |
| cpu\$1tuple\$1cost | Définit l’estimation faite par le planificateur du coût de traitement de chaque tuple (ligne). | – |
| cron.database\$1name | Définit la base de données pour stocker les tables de métadonnées pg\$1cron | postgres |
| cron.log\$1run | Journaliser toutes les exécutions de tâches dans la table job\$1run\$1details | on |
| cron.log\$1statement | Consignez toutes les instructions cron avant exécution. | off |
| cron.max\$1running\$1jobs | Nombre maximal de tâches pouvant être exécutées simultanément. | 5 |
| cron.use\$1background\$1workers | Active les applications de travail en arrière-plan pour pg\$1cron | on |
| cursor\$1tuple\$1fraction | Définit l’estimation faite par le planificateur de la fraction des lignes d’un curseur qui sera récupérée. | – |
| db\$1user\$1namespace | Active les noms d’utilisateurs par base de données. | – |
| deadlock\$1timeout | (ms) Définit le délai d’attente au niveau d’un verrou avant blocage. | – |
| debug\$1pretty\$1print | Indente les affichages des arborescences d’analyse et de planification. | – |
| debug\$1print\$1parse | Journalise l’arborescence d’analyse de chaque requête. | – |
| debug\$1print\$1plan | Journalise le plan d’exécution de chaque requête. | – |
| debug\$1print\$1rewritten | Journalise l’arbre d’interprétation réécrit de chaque requête. | – |
| default\$1statistics\$1target | Définit la cible des statistiques par défaut. | – |
| default\$1transaction\$1deferrable | Définit le statut reportable des nouvelles transactions. | – |
| default\$1transaction\$1isolation | Définit le niveau d’isolement de transaction de chaque nouvelle transaction. | – |
| default\$1transaction\$1read\$1only | Définit le statut en lecture seule des nouvelles transactions. | – |
| effective\$1cache\$1size | (8kB) Définit l’estimation faite par le planificateur de la taille du cache du disque. | SOMME (DBInstanceClassMemory/12038, -50003) |
| effective\$1io\$1concurrency | Nombre de demandes simultanées pouvant être traitées de manière efficace par le sous-système du disque. | – |
| enable\$1async\$1append | Active l’utilisation de plans d’ajout asynchrones par le planificateur. | – |
| enable\$1bitmapscan | Active l’utilisation de plans de parcours de bitmap par le planificateur. | – |
| enable\$1gathermerge | Active l’utilisation de plans de fusions de collecte par le planificateur. | – |
| enable\$1hashagg | Active l’utilisation de plans d’agrégation hachée par le planificateur. | – |
| enable\$1hashjoin | Active l’utilisation de plans de jointures de hachage par le planificateur. | – |
| enable\$1incremental\$1sort | Active l’utilisation d’étapes incrémentielles de tri par le planificateur. | – |
| enable\$1indexonlyscan | Permet aux planificateurs d'utiliser les index-only-scan plans. | – |
| enable\$1indexscan | Active l’utilisation de plans de parcours d’index par le planificateur. | – |
| enable\$1material | Active l’utilisation de la matérialisation par le planificateur. | – |
| enable\$1memoize | Active l’utilisation de la mémorisation par le planificateur. | – |
| enable\$1mergejoin | Active l’utilisation de plans de jointures de fusion par le planificateur. | – |
| enable\$1nestloop | Active l’utilisation de plans de jointures de boucles imbriquées par le planificateur. | – |
| enable\$1parallel\$1append | Active l’utilisation de plans d’ajout parallèles par le planificateur. | – |
| enable\$1parallel\$1hash | Active l’utilisation de plans de hachage parallèles par le planificateur. | – |
| enable\$1partition\$1pruning | Active l’élagage des partitions de planification et d’exécution. | – |
| enable\$1partitionwise\$1aggregate | Active l’agrégation et le regroupement entre partitions. | – |
| enable\$1partitionwise\$1join | Active la jointure entre partitions. | – |
| enable\$1seqscan | Active l’utilisation de plans de parcours séquentiels par le planificateur. | – |
| enable\$1sort | Active l’utilisation des étapes de tri explicite par le planificateur. | – |
| enable\$1tidscan | Active l’utilisation de plans de parcours de TID par le planificateur. | – |
| escape\$1string\$1warning | Avertit sur l’utilisation des barres obliques inverses dans des littéraux de chaîne ordinaires. | – |
| exit\$1on\$1error | Résilie la session en cas d’erreur. | – |
| force\$1parallel\$1mode | Force l’utilisation d’installations de requêtes parallèles. | – |
| from\$1collapse\$1limit | Définit la taille FROM-list au-delà de laquelle les sous-requêtes ne sont pas regroupées. | – |
| geqo | Active l’optimisation génétique des requêtes. | – |
| geqo\$1effort | geqo\$1effort est utilisé pour définir la valeur par défaut pour les autres paramètres GEQO. | – |
| geqo\$1generations | GEQO : nombre d’itérations de l’algorithme. | – |
| geqo\$1pool\$1size | GEQO : nombre d’individus au sein d’une population. | – |
| geqo\$1seed | GEQO : valeur initiale pour la sélection des chemins au hasard. | – |
| geqo\$1selection\$1bias | GEQO : pression de sélectivité au sein de la population. | – |
| geqo\$1threshold | Définit le seuil d’éléments FROM au-delà duquel GEQO est utilisé. | – |
| gin\$1fuzzy\$1search\$1limit | Définit le résultat maximum autorisé pour la recherche exacte par GIN. | – |
| gin\$1pending\$1list\$1limit | (kB) Définit la taille maximale de la liste en attente pour l’index GIN. | – |
| hash\$1mem\$1multiplier | Multiple de work\$1mem à utiliser pour les tables de hachage. | – |
| hba\$1file | Définit le fichier de configuration hba du serveur. | /rdsdbdata/config/pg\$1hba.conf |
| hot\$1standby\$1feedback | Autorise le commentaire d’une instance de secours vers l’instance principale, ce qui évitera les conflits de requêtes. | on |
| ident\$1file | Définit le fichier de configuration ident du serveur. | /rdsdbdata/config/pg\$1ident.conf |
| idle\$1in\$1transaction\$1session\$1timeout | (ms) Définit la durée maximale de toute transaction inactive. | 86400000 |
| idle\$1session\$1timeout | Interrompt toute session qui est restée inactive (c’est-à-dire en attente d’une requête du client), mais qui ne figure pas dans le cadre d’une transaction ouverte, pendant plus longtemps que la durée spécifiée | – |
| join\$1collapse\$1limit | Définit la taille FROM-list au-delà de laquelle les constructions JOIN ne sont pas mises à plat. | – |
| lc\$1messages | Définit la langue d’affichage des messages. | – |
| listen\$1addresses | Définit le nom d’hôte ou l’adresse IP à écouter. | \$1 |
| lo\$1compat\$1privileges | Active le mode de compatibilité descendante pour les vérifications de privilèges sur de larges objets. | 0 |
| log\$1connections | Enregistre toutes les connexions réussies. | – |
| log\$1destination | Définit la destination pour la sortie du journal de serveur. | stderr |
| log\$1directory | Définit le répertoire de destination des fichiers journaux. | /rdsdbdata/log/error |
| log\$1disconnections | Enregistre la fin d’une session, y compris sa durée. | – |
| log\$1duration | Enregistre la durée de chaque instruction SQL terminée. | – |
| log\$1error\$1verbosity | Définit la quantité de détails dans les messages enregistrés. | – |
| log\$1executor\$1stats | Ecrit les statistiques de performance de l’exécuteur dans le journal du serveur. | – |
| log\$1file\$1mode | Définit les autorisations de fichier pour les fichiers journaux. | 0644 |
| log\$1filename | Définit le modèle de nom de fichier pour les fichiers journaux. | postgresql.log.%Y-%m-%d-%H%M |
| logging\$1collector | Démarrez un sous-processus pour capturer les fichiers and/or CSV de sortie stderr dans des fichiers journaux. | 1 |
| log\$1hostname | Enregistre le nom de l’hôte dans les journaux de connexion. | 0 |
| logical\$1decoding\$1work\$1mem | (kB) Cette quantité de mémoire peut être utilisée par chaque tampon interne de réorganisation avant le déversement sur le disque. | – |
| log\$1line\$1prefix | Contrôle les informations préfixées à chaque ligne de journal. | %t:%r:%u@%d:%p]: |
| log\$1lock\$1waits | Enregistre les longs temps d’attente pour l’acquisition d’un verrou. | – |
| log\$1min\$1duration\$1sample | (ms) Définit la durée minimum d’exécution au-delà de laquelle un exemple d’instructions sera journalisé. L’échantillonnage est déterminé par log\$1statement\$1sample\$1rate. | – |
| log\$1min\$1duration\$1statement | (ms) Définit la durée minimum d’exécution au-delà de laquelle les instructions seront journalisées. | – |
| log\$1min\$1error\$1statement | Déclenche l’enregistrement de toutes les instructions générant une erreur à ce niveau ou à un niveau supérieur. | – |
| log\$1min\$1messages | Définit les niveaux des messages qui sont enregistrés. | – |
| log\$1parameter\$1max\$1length | (B) Lors de la journalisation des instructions, limitez les valeurs des paramètres enregistrés aux N premiers octets. | – |
| log\$1parameter\$1max\$1length\$1on\$1error | (B) Lorsque vous signalez une erreur, limitez les valeurs des paramètres enregistrés aux N premiers octets. | – |
| log\$1parser\$1stats | Ecrit les statistiques de performance de l’analyseur dans le journal du serveur. | – |
| log\$1planner\$1stats | Ecrit les statistiques de performance du planificateur dans le journal du serveur. | – |
| log\$1replication\$1commands | Journalise chaque commande de réplication. | – |
| log\$1rotation\$1age | (min) Déclenchement de la rotation de fichier journal automatique au-delà d’un délai de N minutes. | 60 |
| log\$1rotation\$1size | (kB) Déclenchement de la rotation de fichier journal automatique au-delà de N kilo-octets. | 100 000 |
| log\$1statement | Définit le type d’instructions enregistrées. | – |
| log\$1statement\$1sample\$1rate | Partie d’instructions dépassant log\$1min\$1duration\$1sample à journaliser. | – |
| log\$1statement\$1stats | Ecrit les statistiques de performance cumulées dans le journal du serveur. | – |
| log\$1temp\$1files | (kB) Journalise l’utilisation des fichiers temporaires dont la taille est supérieure à cette taille en kilo-octets. | – |
| log\$1timezone | Définit le fuseau horaire à utiliser dans les messages de journaux. | UTC |
| log\$1truncate\$1on\$1rotation | Tronquez les fichiers journaux existants du même nom pendant la rotation des journaux. | 0 |
| maintenance\$1io\$1concurrency | Variante de effective\$1io\$1concurrency utilisée pour les tâches de maintenance. | 1 |
| maintenance\$1work\$1mem | (kB) Définit la quantité maximum de mémoire que peuvent utiliser les opérations de maintenance. | LE PLUS GRAND (DBInstanceClassMemory/63963136 \$11024,65536) |
| max\$1connections | Définit le nombre maximum de connexions simultanées. | AU MOINS (DBInstanceClassMemory/9531392 5000) |
| max\$1files\$1per\$1process | Définit le nombre maximum de fichiers ouverts simultanément pour chaque processus serveur. | – |
| max\$1locks\$1per\$1transaction | Définit le nombre maximum de verrous par transaction. | 64 |
| max\$1parallel\$1maintenance\$1workers | Définit le nombre maximal de processus parallèles par opération de maintenance. | – |
| max\$1parallel\$1workers | Définit le nombre maximal d’applications de travail parallèles pouvant être actives simultanément. | MEILLEUR (\$1 DBInstance VCPU/2,8) |
| max\$1parallel\$1workers\$1per\$1gather | Définit le nombre maximal de processus parallèles par nœud d’exécuteur. | – |
| max\$1pred\$1locks\$1per\$1page | Définit le nombre maximal de tuples verrouillés par prédicat par page. | – |
| max\$1pred\$1locks\$1per\$1relation | Définit le nombre maximum de pages et de tuples verrouillés par prédicat par relation. | – |
| max\$1pred\$1locks\$1per\$1transaction | Définit le nombre maximum de verrous de prédicat par transaction. | – |
| max\$1slot\$1wal\$1keep\$1size | (MB) Les emplacements de réplication seront marqués comme ayant échoué et les segments seront libérés à des fins de suppression ou de recyclage si cette quantité d’espace est occupée par WAL sur le disque. | – |
| max\$1stack\$1depth | (kB) Définit la profondeur maximum de la pile, en kilo-octets. | 6144 |
| max\$1standby\$1streaming\$1delay | (ms) Définit le délai maximum avant l’annulation des requêtes lorsqu’un serveur en zone hébergée traite des données WAL diffusées. | 14000 |
| max\$1worker\$1processes | Définit le nombre maximum de processus de travail simultanés. | MEILLEUR (\$1 DBInstance VCPU\$12,8) |
| min\$1dynamic\$1shared\$1memory | (MB) Quantité de mémoire partagée dynamique réservée au démarrage. | – |
| min\$1parallel\$1index\$1scan\$1size | (8kB) Définit la quantité minimum de données d’index pour une analyse parallèle. | – |
| min\$1parallel\$1table\$1scan\$1size | (8kB) Définit la quantité minimum de données de table pour une analyse parallèle. | – |
| old\$1snapshot\$1threshold | (min) Délai avant qu’un instantané soit trop ancien pour lire les pages modifiées après la prise de l’instantané. | – |
| parallel\$1leader\$1participation | Contrôle si Gather et Gather Merge exécutent également des sous-plans. | – |
| parallel\$1setup\$1cost | Définit l’estimation du planificateur du coût de démarrage des processus de travail pour les requêtes parallèles. | – |
| parallel\$1tuple\$1cost | Définit l’estimation du planificateur du coût de transmission de chaque tuple (ligne) de l’application de travail vers le système dorsal principal. | – |
| pgaudit.log | Spécifie quelles classes d’instructions seront journalisées par la journalisation de l’audit de session. | – |
| pgaudit.log\$1catalog | Spécifie que la journalisation de session doit être activée dans le cas où toutes les relations d’une instruction se trouvent dans pg\$1catalog. | – |
| pgaudit.log\$1level | Spécifie le niveau de journal qui sera utilisé pour les entrées de journal. | – |
| pgaudit.log\$1parameter | Spécifie que la journalisation de l’audit doit inclure les paramètres transmis avec l’instruction. | – |
| pgaudit.log\$1relation | Spécifie si la journalisation de l’audit de session doit créer une entrée de journal distincte pour chaque relation (TABLE, VIEW, etc.) référencée dans une instruction SELECT ou DML. | – |
| pgaudit.log\$1statement\$1once | Spécifie si la journalisation inclura le texte de l'instruction et les paramètres avec la première entrée de journal d'une statement/substatement combinaison ou avec chaque entrée. | – |
| pgaudit.role | Spécifie le rôle principal à utiliser pour la journalisation de l’audit des objets. | – |
| pg\$1bigm.enable\$1recheck | Spécifie s’il faut effectuer une revérification qui est un processus interne de recherche en texte intégral. | on |
| pg\$1bigm.gin\$1key\$1limit | Spécifie le nombre maximum de 2 grammes du mot-clé de recherche à utiliser pour la recherche en texte intégral. | 0 |
| pg\$1bigm.last\$1update | Indique la dernière date de mise à jour du module pg\$1bigm. | 2013.11.22 |
| pg\$1bigm.similarity\$1limit | Spécifie le seuil minimal utilisé par la recherche de similarité. | 0.3 |
| pg\$1hint\$1plan.debug\$1print | Journalise les résultats de l’analyse des indices. | – |
| pg\$1hint\$1plan.enable\$1hint | Force le planificateur à utiliser les plans spécifiés dans le commentaire d’indice précédant la requête. | – |
| pg\$1hint\$1plan.enable\$1hint\$1table | Force le planificateur à ne pas obtenir d’indice à l’aide des recherches de table. | – |
| pg\$1hint\$1plan.message\$1level | Niveau de message des messages de débogage. | – |
| pg\$1hint\$1plan.parse\$1messages | Niveau de message des erreurs d’analyse. | – |
| pglogical.batch\$1inserts | Insertions de lots si possible | – |
| pglogical.conflict\$1log\$1level | Définit le niveau de journal utilisé pour la journalisation des conflits résolus. | – |
| pglogical.conflict\$1resolution | Définit la méthode utilisée pour la résolution des conflits résolubles. | – |
| pglogical.extra\$1connection\$1options | options de connexion à ajouter à toutes les connexions de nœuds de pairs | – |
| pglogical.synchronous\$1commit | valeur de validation synchrone spécifique pglogical | – |
| pglogical.use\$1spi | Utiliser une SPI au lieu d’une API de bas niveau pour appliquer les modifications | – |
| pg\$1similarity.block\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.block\$1threshold | Définit le seuil utilisé par la fonction de similarité Block. | – |
| pg\$1similarity.block\$1tokenizer | Définit le créateur de jetons pour la fonction de similarité Block. | – |
| pg\$1similarity.cosine\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.cosine\$1threshold | Définit le seuil utilisé par la fonction de similarité Cosine. | – |
| pg\$1similarity.cosine\$1tokenizer | Définit le créateur de jetons pour la fonction de similarité Cosine. | – |
| pg\$1similarity.dice\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.dice\$1threshold | Définit le seuil utilisé par la mesure de similarité Dice. | – |
| pg\$1similarity.dice\$1tokenizer | Définit le créateur de jetons pour la mesure de similarité Dice. | – |
| pg\$1similarity.euclidean\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.euclidean\$1threshold | Définit le seuil utilisé par la mesure de similarité Euclidean. | – |
| pg\$1similarity.euclidean\$1tokenizer | Définit le créateur de jetons pour la mesure de similarité Euclidean. | – |
| pg\$1similarity.hamming\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.hamming\$1threshold | Définit le seuil utilisé par la mesure de similarité Block. | – |
| pg\$1similarity.jaccard\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.jaccard\$1threshold | Définit le seuil utilisé par la mesure de similarité Jaccard. | – |
| pg\$1similarity.jaccard\$1tokenizer | Définit le créateur de jetons pour la mesure de similarité Jaccard. | – |
| pg\$1similarity.jaro\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.jaro\$1threshold | Définit le seuil utilisé par la mesure de similarité Jaro. | – |
| pg\$1similarity.jarowinkler\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.jarowinkler\$1threshold | Définit le seuil utilisé par la mesure de similarité Jarowinkler. | – |
| pg\$1similarity.levenshtein\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.levenshtein\$1threshold | Définit le seuil utilisé par la mesure de similarité Levenshtein. | – |
| pg\$1similarity.matching\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.matching\$1threshold | Définit le seuil utilisé par la mesure de similarité Matching Coefficient. | – |
| pg\$1similarity.matching\$1tokenizer | Définit le créateur de jetons pour la mesure de similarité Matching Coefficient. | – |
| pg\$1similarity.mongeelkan\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.mongeelkan\$1threshold | Définit le seuil utilisé par la mesure de similarité Monge-Elkan. | – |
| pg\$1similarity.mongeelkan\$1tokenizer | Définit le créateur de jetons pour la mesure de similarité Monge-Elkan. | – |
| pg\$1similarity.nw\$1gap\$1penalty | Définit la pénalité d’écart utilisée par la mesure de similarité Needleman-Wunsch. | – |
| pg\$1similarity.nw\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.nw\$1threshold | Définit le seuil utilisé par la mesure de similarité Needleman-Wunsch. | – |
| pg\$1similarity.overlap\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.overlap\$1threshold | Définit le seuil utilisé par la mesure de similarité Overlap Coefficient. | – |
| pg\$1similarity.overlap\$1tokenizer | Définit le créateur de jetons pour la mesure de similarité Overlap Coefficient. | – |
| pg\$1similarity.qgram\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.qgram\$1threshold | Définit le seuil utilisé par la mesure de similarité Q-Gram. | – |
| pg\$1similarity.qgram\$1tokenizer | Définit le créateur de jetons pour la mesure Q-Gram. | – |
| pg\$1similarity.swg\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.swg\$1threshold | Définit le seuil utilisé par la mesure de Smith-Waterman-Gotoh similarité. | – |
| pg\$1similarity.sw\$1is\$1normalized | Définit si la valeur du résultat est normalisée ou non. | – |
| pg\$1similarity.sw\$1threshold | Définit le seuil utilisé par la mesure de similarité Smith-Waterman. | – |
| pg\$1stat\$1statements.max | Définit le nombre maximal d’instructions suivies par pg\$1stat\$1statements. | – |
| pg\$1stat\$1statements.save | Enregistre les statistiques pg\$1stat\$1statements sur les arrêts de serveur. | – |
| pg\$1stat\$1statements.track | Définit les instructions qui sont suivies par pg\$1stat\$1statements. | – |
| pg\$1stat\$1statements.track\$1planning | Définit si le délai de planification est suivi par pg\$1stat\$1statements. | – |
| pg\$1stat\$1statements.track\$1utility | Définit si les commandes d’utilitaire sont suivies par pg\$1stat\$1statements. | – |
| postgis.gdal\$1enabled\$1drivers | Activez ou désactivez les pilotes GDAL utilisés avec PostGIS dans Postgres 9.3.5 et versions ultérieures. | ENABLE\$1ALL |
| quote\$1all\$1identifiers | Lors de la génération de fragments SQL, ajoute des guillemets à tous les identifiants. | – |
| random\$1page\$1cost | Définit l’estimation faite par le planificateur du coût d’une page de disque extraite de façon non séquentielle. | – |
| rds.enable\$1memory\$1management | Améliore les fonctionnalités de gestion de mémoire dans Aurora PostgreSQL 12.17, 13.13, 14.10, 15.5 et les versions ultérieures, empêchant ainsi les problèmes de stabilité et les redémarrages de base de données provoqués par une mémoire disponible insuffisante. Pour plus d’informations, consultez [Gestion de mémoire améliorée dans Aurora PostgreSQLLimitation](AuroraPostgreSQL.BestPractices.memory.management.md). | True |
| rds.force\$1admin\$1logging\$1level | Consultez les messages de journalisation des actions d’utilisateur de l’administrateur RDS dans les bases de données clients. | – |
| rds.log\$1retention\$1period | Amazon RDS supprimera les journaux PostgreSQL antérieurs à N minutes. | 4320 |
| rds.memory\$1allocation\$1guard | Améliore les fonctionnalités de gestion de mémoire dans Aurora PostgreSQL 11.21, 12.16, 13.12, 14.9, 15.4 et les versions ultérieures, empêchant ainsi les problèmes de stabilité et les redémarrages de base de données provoqués par une mémoire disponible insuffisante. Pour plus d’informations, consultez [Gestion de mémoire améliorée dans Aurora PostgreSQLLimitation](AuroraPostgreSQL.BestPractices.memory.management.md). | False |
| rds.pg\$1stat\$1ramdisk\$1size | Taille du disque RAM des statistiques en Mo. Une valeur différente de zéro va configurer le disque RAM. | 0 |
| rds.rds\$1superuser\$1reserved\$1connections | Définit le nombre d’emplacements de connexion réservés pour rds\$1superusers. Ce paramètre est uniquement disponible dans les versions 15 et antérieures. Pour plus d’informations, consultez la documentation de PostgreSQL sur [reserved\$1connections](https://www.postgresql.org/docs/current/runtime-config-connection.html#GUC-RESERVED-CONNECTIONS). | 2 |
| rds.superuser\$1variables | Liste des variables réservées aux super-utilisateurs pour lesquelles nous augmentons les instructions de modification rds\$1superuser. | session\$1replication\$1role |
| remove\$1temp\$1files\$1after\$1crash | Supprime les fichiers temporaires après l’arrêt du système dorsal. | 0 |
| restart\$1after\$1crash | Réinitialisez le serveur après l’arrêt du système dorsal. | – |
| row\$1security | Activez la sécurité au niveau des lignes. | – |
| search\$1path | Définit l’ordre de recherche des schémas pour les noms pour lesquels le schéma n’est pas précisé. | – |
| seq\$1page\$1cost | Définit l’estimation faite par le planificateur du coût d’une page de disque extraite de façon séquentielle. | – |
| session\$1replication\$1role | Définit le comportement des sessions concernant les déclencheurs et les règles de réécriture. | – |
| shared\$1buffers | (8kB) Définit le nombre de tampons de mémoire partagée utilisés par le serveur. | SOMME (DBInstanceClassMemory/12038, -50003) |
| shared\$1preload\$1libraries | Répertorie les bibliothèques partagées à précharger sur le serveur. | pg\$1stat\$1statements |
| ssl\$1ca\$1file | Emplacement du fichier d’autorité du serveur SSL. | /rdsdbdata/rds-metadata/ca-cert.pem |
| ssl\$1cert\$1file | Emplacement du fichier de certificat du serveur SSL. | /rdsdbdata/rds-metadata/server-cert.pem |
| ssl\$1crl\$1dir | Emplacement du répertoire de la liste de révocation des certificats SSL. | /rdsdbdata/rds-metadata/ssl\$1crl\$1dir/ |
| ssl\$1key\$1file | Emplacement du fichier de clé privée du serveur SSL | /rdsdbdata/rds-metadata/server-key.pem |
| standard\$1conforming\$1strings | Entraîne les chaînes ... à traiter littéralement les barres obliques inverses. | – |
| statement\$1timeout | (ms) Définit la durée maximum de toute instruction. | – |
| stats\$1temp\$1directory | Écrit des fichiers de statistiques temporaires dans le répertoire spécifié. | /rdsdbdata/db/pg\$1stat\$1tmp |
| superuser\$1reserved\$1connections | Définit le nombre d’emplacements de connexion réservés aux super-utilisateurs. | 3 |
| synchronize\$1seqscans | Active les analyses séquentielles synchronisées. | – |
| tcp\$1keepalives\$1count | Nombre maximum de paquets TCP keepalive. | – |
| tcp\$1keepalives\$1idle | (s) Délai entre les émissions de paquets TCP keepalive. | – |
| tcp\$1keepalives\$1interval | (s) Délai entre les envois de paquets TCP keepalive. | – |
| temp\$1buffers | (8kB) Définit le nombre maximum de tampons temporaires utilisés par chaque session. | – |
| temp\$1file\$1limit | Contraint l’espace disque total en kilo-octets qu’un processus PostgreSQL donné peut utiliser pour les fichiers temporaires, à l’exclusion de l’espace utilisé pour les tables temporaires explicites | -1 |
| temp\$1tablespaces | Définit les espaces de table à utiliser pour les tables et fichiers de tri temporaires. | – |
| track\$1activities | Active la collecte d’informations sur l’exécution des commandes. | – |
| track\$1activity\$1query\$1size | Définit la taille réservée pour pg\$1stat\$1activity.current\$1query, en octets. | 4096 |
| track\$1counts | Active la collecte de statistiques sur l’activité de la base de données. | – |
| track\$1functions | Active la collecte de statistiques au niveau de la fonction sur l’activité de la base de données. | pl |
| track\$1io\$1timing | Active la collecte de statistiques de durée sur l’activité I/O de la base de données. | 1 |
| transform\$1–\$1equals | Traite expr=– en tant que IS –. | – |
| update\$1process\$1title | Met à jour le titre du processus pour indiquer la commande SQL active. | – |
| wal\$1receiver\$1status\$1interval | (s) Définit l’intervalle maximal entre les rapports d’état du récepteur WAL et le principal. | – |
| work\$1mem | (kB) Définit la quantité maximum de mémoire que peuvent utiliser les espaces de travail des requêtes. | – |
| xmlbinary | Définit la façon dont les valeurs binaires doivent être codées en XML. | – |
| xmloption | Définit si des données XML dans des opérations d’analyse ou de sérialisation implicites doivent être considérées comme des documents ou des fragments de contenu. | – |
# Événements d’attente Amazon Aurora PostgreSQL
Voici les événements d’attente courants pour Aurora PostgreSQL. Pour en savoir plus sur les événements d’attente et le réglage de votre cluster de bases de données Aurora PostgreSQL, consultez [Réglage des événements d’attente pour Aurora PostgreSQL](AuroraPostgreSQL.Tuning.md).
**Activité : ArchiverMain**
Le processus d’archivage est en attente d’activité.
**Activité : AutoVacuumMain**
Le processus de lancement de l’autovacuum est en attente d’activité.
**Activité : BgWriterHibernate**
Le processus d’écriture en arrière-plan est en veille prolongée lors de l’attente d’activité.
**Activité : BgWriterMain**
Le processus d’écriture en arrière-plan est en attente d’activité.
**Activité : CheckpointerMain**
Le processus du pointeur de contrôle est en attente d’activité.
**Activité : LogicalApplyMain**
Le processus d’application de réplication logique est en attente d’activité.
**Activité : LogicalLauncherMain**
Le processus de lancement de réplication logique est en attente d’activité.
**Activité : PgStatMain**
Le processus de collecte de statistiques est en attente d’activité.
**Activité : RecoveryWalAll**
Un processus est en attente du journal d’écriture anticipée (WAL) à partir d’un flux lors de la récupération.
**Activité : RecoveryWalStream**
Le processus de démarrage est en attente de l’arrivée du journal d’écriture anticipée (WAL) pendant la récupération du streaming.
**Activité : SysLoggerMain**
Le processus syslogger est en attente d’activité.
**Activité : WalReceiverMain**
Le processus de réception du journal d’écriture anticipée (WAL) est en attente d’activité.
**Activité : WalSenderMain**
Le processus d’expédition WAL est en attente d’activité.
**Activité : WalWriterMain**
Le processus d’écriture WAL est en attente d’activité.
**BufferPin:BufferPin**
Un processus attend d’acquérir une connexion exclusive sur un tampon.
**Client : GSSOpen serveur**
Un processus attend de lire les données du client lors de l’établissement d’une session GSSAPI (Generic Security Service Application Program Interface).
**Cliente : ClientRead**
Un processus dorsal attend de recevoir des données d’un client PostgreSQL. Pour de plus amples informations, veuillez consulter [Cliente : ClientRead](apg-waits.clientread.md).
**Cliente : ClientWrite**
Un processus dorsal attend d’envoyer davantage de données à un client PostgreSQL. Pour de plus amples informations, veuillez consulter [Cliente : ClientWrite](apg-waits.clientwrite.md).
**Client : Lib PQWal ReceiverConnect**
Un processus est en attente dans le récepteur du journal d’écriture anticipée (WAL) d’établir la connexion au serveur distant.
**Client : Lib PQWal ReceiverReceive**
Un processus est en attente dans le récepteur WAL de réception des données du serveur distant.
**Client : SSLOpen serveur**
Un processus est en attente du protocole SSL pendant la tentative de connexion.
**Cliente : WalReceiverWaitStart**
Un processus attend que le processus de démarrage envoie des données initiales pour la réplication du streaming.
**Client : WalSenderWaitFor WAL**
Un processus attend le vidage du journal d’écriture anticipée (WAL) dans le processus d’expédition WAL.
**Cliente : WalSenderWriteData**
Un processus est en attente d’activité lors du traitement des réponses provenant du récepteur WAL du processus d’expédition WAL.
**CPU**
Un processus de backend est actif ou en attente du processeur. Pour plus d’informations, consultez [CPU](apg-waits.cpu.md).
**Extension:extension**
Un processus dorsal est en attente d’une condition définie par une extension ou un module.
**IO : AuroraEnhancedLogical WALRead**
Un processus dorsal extrait les enregistrements du journal depuis le volume de capture des données modifiées (CDC).
**IO : AuroraOptimizedReadsCacheRead**
Un processus est en attente d’une lecture du cache à plusieurs niveaux Optimized Reads, car la page n’est pas disponible en mémoire partagée.
**IO : AuroraOptimizedReads CacheSegmenttronquer**
Un processus est en attente de la troncature d’un fichier de segments du cache à plusieurs niveaux Optimized Reads.
**IO : AuroraOptimizedReadsCacheWrite**
Le processus d’écriture en arrière-plan est en attente d’une écriture dans le cache à plusieurs niveaux Optimized Reads.
**IO : AuroraStorageLogAllocate**
Une session alloue des métadonnées et prépare l’écriture d’un journal de transactions.
**IO : BufFileRead**
Lorsque les opérations nécessitent plus de mémoire que la quantité définie par les paramètres de mémoire de travail, le moteur crée des fichiers temporaires sur le disque. Cet événement d’attente se produit lorsque les opérations sont lues à partir des fichiers temporaires. Pour de plus amples informations, veuillez consulter [IO : BufFileRead et IO : BufFileWrite](apg-waits.iobuffile.md).
**IO : BufFileWrite**
Lorsque les opérations nécessitent plus de mémoire que la quantité définie par les paramètres de mémoire de travail, le moteur crée des fichiers temporaires sur le disque. Cet événement d’attente se produit lorsque les opérations sont écrites dans des fichiers temporaires. Pour de plus amples informations, veuillez consulter [IO : BufFileRead et IO : BufFileWrite](apg-waits.iobuffile.md).
**IO : ControlFileRead**
Un processus est en attente d’une lecture du fichier `pg_control`.
**IO : ControlFileSync**
Un processus attend que le fichier `pg_control` atteigne un stockage durable.
**IO : ControlFileSyncUpdate**
Un processus est en attente qu’une mise à jour du fichier `pg_control` atteigne un stockage durable.
**IO : ControlFileWrite**
Un processus est en attente d’une écriture dans le fichier `pg_control`.
**IO : ControlFileWriteUpdate**
Un processus est en attente d’une écriture de mise à jour du fichier `pg_control`.
**IO : CopyFileRead**
Un processus est en attente de lecture pendant une opération de copie de fichier.
**IO : CopyFileWrite**
Un processus est en attente d’une écriture pendant une opération de copie de fichier.
**IO : DataFileExtend**
Un processus attend qu’un fichier de données de relation soit étendu.
**IO : DataFileFlush**
Un processus est en attente qu’un fichier de données de relation atteigne un stockage durable.
**IO : DataFileImmediateSync**
Un processus est en attente de synchronisation immédiate d’un fichier de données de relation sur un stockage durable.
**IO : DataFilePrefetch**
Un processus est en attente d’une récupération préalable asynchrone depuis un fichier de données de relation.
**IO : DataFileSync**
Un processus est en attente de modification d’un fichier de données de relation sur un stockage durable.
**IO : DataFileRead**
Un processus dorsal a essayé de trouver une page dans les tampons partagés, ne l’a pas trouvée et l’a donc lue depuis le stockage. Pour de plus amples informations, veuillez consulter [IO : DataFileRead](apg-waits.iodatafileread.md).
**IO : DataFileTruncate**
Un processus attend qu’un fichier de données de relation soit tronqué.
**IO : DataFileWrite**
Un processus est en attente d’une écriture dans un fichier de données de relation.
**IO : DSMFill ZeroWrite**
Un processus attend d’écrire zéro octet dans un fichier de sauvegarde dynamique de mémoire partagée.
**IO : LockFileAddToDataDirRead**
Un processus est en attente d’une lecture lors de l’ajout d’une ligne au fichier de verrouillage du répertoire de données.
**IO : LockFileAddToDataDirSync**
Un processus est en attente que les données atteignent un stockage durable lors de l’ajout d’une ligne au fichier de verrouillage du répertoire de données.
**IO : LockFileAddToDataDirWrite**
Un processus est en attente d’une écriture lors de l’ajout d’une ligne au fichier de verrouillage du répertoire de données.
**IO : LockFileCreateRead**
Un processus est en attente d’une lecture lors de la création du fichier de verrouillage du répertoire de données.
**IO : LockFileCreateSync**
Un processus est en attente que les données atteignent un stockage durable lors de la création du fichier de verrouillage du répertoire de données.
**IO : LockFileCreateWrite**
Un processus est en attente d’une écriture lors de la création du fichier de verrouillage du répertoire de données.
**IO : LockFileReCheckDataDirRead**
Un processus est en attente d’une lecture lors de la revérification du fichier de verrouillage du répertoire de données.
**IO : LogicalRewriteCheckpointSync**
Un processus attend que des mappages de réécriture logiques atteignent un stockage durable pendant un point de contrôle.
**IO : LogicalRewriteMappingSync**
Un processus attend que les données de mappage atteignent un stockage durable pendant une réécriture logique.
**IO : LogicalRewriteMappingWrite**
Un processus est en attente d’une écriture de données de mappage lors d’une réécriture logique.
**IO : LogicalRewriteSync**
Un processus attend que les mappages de réécriture logique atteignent un stockage durable.
**IO : LogicalRewriteTruncate**
Un processus est en attente de la troncature des données de mappage lors d’une réécriture logique.
**IO : LogicalRewriteWrite**
Un processus est en attente d’une écriture des mappages de réécriture logique.
**IO : RelationMapRead**
Un processus est en attente d’une lecture d’un fichier de mappage de relation.
**IO : RelationMapSync**
Un processus est en attente que le fichier de mappage de relation atteigne un stockage durable.
**IO : RelationMapWrite**
Un processus est en attente d’une écriture dans le fichier de mappage de relation.
**IO : ReorderBufferRead**
Un processus est en attente d’une lecture pendant la gestion du tampon de réorganisation.
**IO : ReorderBufferWrite**
Un processus est en attente d’une écriture pendant la gestion de la mémoire tampon de réorganisation.
**IO : ReorderLogicalMappingRead**
Un processus est en attente d’une lecture d’un mappage logique pendant la gestion de la mémoire tampon de réorganisation.
**IO : ReplicationSlotRead**
Un processus est en attente d’une lecture à partir d’un fichier de contrôle d’emplacement de réplication.
**IO : ReplicationSlotRestoreSync**
Un processus attend qu’un fichier de contrôle d’emplacement de réplication atteigne un stockage durable tout en le rétablissant en mémoire.
**IO : ReplicationSlotSync**
Un processus attend qu’un fichier de contrôle d’emplacement de réplication atteigne un stockage durable.
**IO : ReplicationSlotWrite**
Un processus est en attente d’une écriture sur un fichier de contrôle d’emplacement de réplication.
**IO : SLRUFlush Synchronisation**
Un processus attend que les données simples les moins récemment utilisées (SLRU) atteignent un stockage durable lors d’un point de contrôle ou de l’arrêt de la base de données.
**IO : SLRURead**
Un processus attend la lecture d’une page simple la moins récemment utilisée (SLRU).
**IO : SLRUSync**
Un processus attend que les données simples les moins récemment utilisées (SLRU) atteignent un stockage durable après l’écriture d’une page.
**IO : SLRUWrite**
Un processus attend l’écriture d’une page simple la moins récemment utilisée (SLRU).
**IO : SnapbuildRead**
Un processus attend la lecture d’un instantané de catalogue historique sérialisé.
**IO : SnapbuildSync**
Un processus attend qu’un instantané de catalogue historique sérialisé atteigne un stockage durable.
**IO : SnapbuildWrite**
Un processus attend l’écriture d’un instantané de catalogue historique sérialisé.
**IO : TimelineHistoryFileSync**
Un processus attend qu’un fichier d’historique de chronologie reçu via la réplication de streaming atteigne un stockage durable.
**IO : TimelineHistoryFileWrite**
Un processus attend qu’une écriture d’un fichier d’historique de chronologie soit reçu via la réplication de streaming.
**IO : TimelineHistoryRead**
Un processus est en attente de lecture d’un fichier d’historique de chronologie.
**IO : TimelineHistorySync**
Un processus attend qu’un fichier d’historique de chronologie nouvellement créé atteigne un stockage durable.
**IO : TimelineHistoryWrite**
Un processus est en attente d’écriture d’un fichier d’historique de chronologie nouvellement créé.
**IO : TwophaseFileRead**
Un processus attend la lecture d’un fichier d’état à deux phases.
**IO : TwophaseFileSync**
Un processus est en attente qu’un fichier d’état à deux phases atteigne un stockage durable.
**IO : TwophaseFileWrite**
Un processus attend une écriture d’un fichier d’état à deux phases.
**IO : WALBootstrap Synchronisation**
Un processus attend que le journal d’écriture anticipée (WAL) atteigne un stockage durable pendant l’action d’amorçage.
**IO : WALBootstrap Écrivez**
Un processus est en attente d’écriture d’une page d’un journal d’écriture anticipée (WAL) pendant l’action d’amorçage.
**IO : WALCopy Lire**
Un processus attend la lecture lors de la création d’un nouveau segment de journal d’écriture anticipée (WAL) en copiant un segment existant.
**IO : WALCopy Synchronisation**
Un processus attend qu’un nouveau segment WAL créé en copiant un segment existant atteigne un stockage durable.
**IO : WALCopy Écrivez**
Un processus attend une écriture lors de la création d’un nouveau segment WAL en copiant un segment existant.
**IO : WALInit Synchronisation**
Un processus attend qu’un fichier de journal d’écriture anticipée (WAL) nouvellement initialisé atteigne un stockage durable.
**IO : WALInit Écrivez**
Un processus est en attente d’une écriture lors de l’initialisation d’un nouveau fichier de journal d’écriture anticipée (WAL).
**IO : WALRead**
Un processus est en attente d’une lecture à partir d’un fichier de journal d’écriture anticipée (WAL).
**IO : WALSender TimelineHistoryRead**
Un processus est en attente d’une lecture à partir d’un fichier d’historique de chronologie pendant une commande de chronologie d’expédition WAL.
**IO : WALSync**
Un processus attend qu’un fichier WAL atteigne un stockage durable.
**IO : WALSync MethodAssign**
Un processus attend que les données atteignent un stockage durable lors de l’affectation d’une nouvelle méthode de synchronisation WAL.
**IO : WALWrite**
Un processus est en attente d’une écriture dans un fichier WAL.
**IO : XactSync**
Un processus dorsal attend que le sous-système de stockage Aurora confirme la validation d’une transaction standard, ou la validation ou restauration d’une transaction préparée. Pour de plus amples informations, veuillez consulter [IO:XactSync](apg-waits.xactsync.md).
**IPC : AuroraLogicalSchemaUpdate**
Deux processus dorsaux tentent d’insérer la même entrée dans le cache du schéma. Un seul processus se poursuit pendant que l’autre attend qu’il se termine.
**IPC : AuroraOptimizedReadsCacheWriteStop**
Un processus attend que l’enregistreur en arrière-plan arrête d’écrire dans le cache à plusieurs niveaux Optimized Reads.
**IPC : BackupWaitWalArchive**
Un processus attend les fichiers du journal d’écriture anticipée (WAL) nécessaires à l’archivage réussi d’une sauvegarde.
**IPC : BgWorkerShutdown**
Un processus attend la fermeture d’une application de travail en arrière-plan.
**IPC : BgWorkerStartup**
Un processus attend le démarrage d’une application de travail en arrière-plan.
**IPC : BtreePage**
Un processus est en attente de la disponibilité du numéro de page nécessaire pour poursuivre une analyse parallèle de l’arborescence B.
**IPC : CheckpointDone**
Un processus attend la fin d’un point de contrôle.
**IPC : CheckpointStart**
Un processus attend le début d’un point de contrôle.
**IPC : ClogGroupUpdate**
Un processus attend que le chef de groupe mette à jour le statut de la transaction à la fin d’une transaction.
**IPC : DamRecordTxAck**
Un processus dorsal a généré un événement de flux d’activité de base de données et attend que l’événement devienne durable. Pour de plus amples informations, veuillez consulter [IPC:DamRecordTxAck](apg-waits.ipcdamrecordtxac.md).
**IPC : ExecuteGather**
Un processus attend l’activité d’un processus enfant lors de l’exécution d’un nœud de plan Gather.
**IPC : Hash/Batch/Allocating**
Un processus attend qu’un participant au hachage parallèle élu alloue une table de hachage.
**IPC : Hash/Batch/Electing**
Un processus élit un participant au hachage parallèle pour allouer une table de hachage.
**IPC : Hash/Batch/Loading**
Un processus attend que d’autres participants au hachage parallèle terminent le chargement d’une table de hachage.
**IPC : Hash/Build/Allocating**
Un processus attend qu’un participant au hachage parallèle élu alloue la table de hachage initiale.
**IPC : Hash/Build/Electing**
Un processus élit un participant au hachage parallèle pour allouer la table de hachage initiale.
**IPC : Hash/Build/HashingInner**
Un processus attend que d’autres participants au hachage parallèle terminent le hachage de la relation interne.
**IPC : Hash/Build/HashingOuter**
Un processus attend que d’autres participants au hachage parallèle terminent le partitionnement de la relation externe.
**IPC : Hash/GrowBatches/Allocating**
Un processus attend qu’un participant au hachage parallèle élu alloue d’autres lots.
**IPC : Hash/GrowBatches/Deciding**
Un processus élit un participant au hachage parallèle pour décider de la croissance future des lots.
**IPC : Hash/GrowBatches/Electing**
Un processus élit un participant au hachage parallèle pour allouer plus de lots.
**IPC : Hash/GrowBatches/Finishing**
Un processus attend qu’un participant au hachage parallèle élu décide de la croissance future des lots.
**IPC : Hash/GrowBatches/Repartitioning**
Un processus attend que d’autres participants au hachage parallèle terminent le partitionnement.
**IPC : Hash/GrowBuckets/Allocating**
Un processus attend qu’un participant au hachage parallèle élu finisse d’allouer plus de compartiments.
**IPC : Hash/GrowBuckets/Electing**
Un processus élit un participant au hachage parallèle pour allouer plus de compartiments.
**IPC : Hash/GrowBuckets/Reinserting**
Un processus attend que d’autres participants au hachage parallèle finissent d’insérer des tuples dans de nouveaux compartiments.
**IPC : HashBatchAllocate**
Un processus attend qu’un participant au hachage parallèle élu alloue une table de hachage.
**IPC : HashBatchElect**
Un processus attend d’élire un participant au hachage parallèle pour allouer une table de hachage.
**IPC : HashBatchLoad**
Un processus attend que d’autres participants au hachage parallèle terminent le chargement d’une table de hachage.
**IPC : HashBuildAllocate**
Un processus attend qu’un participant au hachage parallèle élu alloue la table de hachage initiale.
**IPC : HashBuildElect**
Un processus attend d’élire un participant au hachage parallèle pour allouer la table de hachage initiale.
**IPC : HashBuildHashInner**
Un processus attend que d’autres participants au hachage parallèle terminent le hachage de la relation interne.
**CIP : 'HashBuildHashOuter**
Un processus attend que d’autres participants au hachage parallèle terminent le partitionnement de la relation externe.
**IPC : HashGrowBatchesAllocate**
Un processus attend qu’un participant au hachage parallèle élu alloue d’autres lots.
**CIP : 'HashGrowBatchesDecide**
Un processus attend d’élire un participant au hachage parallèle pour décider de la croissance future des lots.
**IPC : HashGrowBatchesElect**
Un processus attend d’élire un participant au hachage parallèle pour allouer d’autres lots.
**IPC : HashGrowBatchesFinish**
Un processus attend qu’un participant au hachage parallèle élu décide de la croissance future des lots.
**IPC : HashGrowBatchesRepartition**
Un processus attend que d’autres participants au hachage parallèle terminent le partitionnement.
**IPC : HashGrowBucketsAllocate**
Un processus attend qu’un participant au hachage parallèle élu finisse d’allouer plus de compartiments.
**IPC : HashGrowBucketsElect**
Un processus attend d’élire un participant au hachage parallèle pour allouer plus de compartiments.
**IPC : HashGrowBucketsReinsert**
Un processus attend que d’autres participants au hachage parallèle finissent d’insérer des tuples dans de nouveaux compartiments.
**IPC : LogicalSyncData**
Un processus attend qu’un serveur distant de réplication logique envoie des données pour la synchronisation initiale de la table.
**IPC : LogicalSyncStateChange**
Un processus attend qu’un serveur distant de réplication logique change d’état.
**IPC : MessageQueueInternal**
Un processus attend qu’un autre processus soit attaché à une file d’attente de messages partagée.
**IPC : MessageQueuePutMessage**
Un processus attend d’écrire un message de protocole dans une file d’attente de messages partagée.
**IPC : MessageQueueReceive**
Un processus attend de recevoir des octets d’une file d’attente de messages partagée.
**IPC : MessageQueueSend**
Un processus attend d’envoyer des octets à une file d’attente de messages partagée.
**IPC : ParallelBitmapScan**
Un processus attend l’initialisation d’une analyse bitmap parallèle.
**IPC : ParallelCreateIndexScan**
Un processus attend que les applications de travail CREATE INDEX parallèles terminent une analyse de pile.
**IPC : ParallelFinish**
Un processus attend que les applications de travail parallèles terminent le calcul.
**IPC : ProcArrayGroupUpdate**
Un processus attend que le chef de groupe efface le statut de la transaction à la fin de la transaction.
**IPC : ProcSignalBarrier**
Un processus attend qu’un événement de barrière soit traité par tous les systèmes dorsaux.
**IPC:Promote**
Un processus attend une promotion en attente.
**IPC : RecoveryConflictSnapshot**
Un processus attend la résolution des conflits de récupération pour un nettoyage par le vide.
**IPC : RecoveryConflictTablespace**
Un processus attend la résolution des conflits de récupération pour supprimer un espace de table.
**IPC : RecoveryPause**
Un processus attend la reprise de la récupération.
**IPC : ReplicationOriginDrop**
Un processus attend qu’une origine de réplication devienne inactive pour pouvoir la supprimer.
**IPC : ReplicationSlotDrop**
Un processus attend qu’un emplacement de réplication devienne inactif pour pouvoir le supprimer.
**IPC : SafeSnapshot**
Un processus attend d’obtenir un instantané valide pour une transaction READ ONLY DEFERRABLE.
**IPC : SyncRep**
Un processus est en attente de confirmation de la part d’un serveur distant pendant la réplication synchrone.
**IPC : XactGroupUpdate**
Un processus attend que le chef de groupe mette à jour le statut de la transaction à la fin de la transaction.
**Lock:advisory**
Un processus dorsal a demandé un verrou consultatif et l’attend. Pour plus d’informations, consultez [Lock:advisory](apg-waits.lockadvisory.md).
**Lock:extend**
Un processus dorsal attend qu’un verrou soit libéré afin de pouvoir étendre une relation. Ce verrou est nécessaire car un seul processus de backend peut étendre une relation à la fois. Pour plus d’informations, consultez [Lock:extend](apg-waits.lockextend.md).
**Lock:frozenid**
Un processus est en attente de mise à jour de `pg_database.datfrozenxid` et `pg_database.datminmxid`.
**Lock:object**
Un processus attend d’obtenir un verrou sur un objet de base de données sans relation.
**Lock:page**
Un processus attend d’obtenir un verrou sur une page d’une relation.
**Lock:Relation**
Un processus dorsal attend d’acquérir un verrou sur une relation verrouillée par une autre transaction. Pour plus d’informations, consultez [Lock:Relation](apg-waits.lockrelation.md).
**Lock:spectoken**
Un processus attend d’obtenir un verrou d’insertion spéculatif.
**Lock:speculative token**
Un processus attend d’acquérir un verrou d’insertion spéculatif.
**Lock:transactionid**
Une transaction est en attente d’un verrou au niveau de la ligne. Pour plus d’informations, consultez [Lock:transactionid](apg-waits.locktransactionid.md).
**Lock:tuple**
Un processus dorsal attend d’acquérir un verrou sur un tuple alors qu’un autre processus dorsal contient un verrou conflictuel sur le même tuple. Pour plus d’informations, consultez [Lock:tuple](apg-waits.locktuple.md).
**Lock:userlock**
Un processus attend d’obtenir un verrou utilisateur.
**Lock:virtualxid**
Un processus attend d’obtenir un verrou d’ID de transaction virtuel.
**LWLock:AddinShmemInit**
Un processus est en attente de gestion de l’allocation d’espace d’une extension dans la mémoire partagée.
**LWLock:AddinShmemInitLock**
Un processus est en attente de gestion de l’allocation d’espace dans la mémoire partagée.
**LWLock:asynchrone**
Un processus est en attente I/O sur une mémoire tampon asynchrone (notification).
**LWLock:AsyncCtlLock**
Un processus est en attente de lecture ou de mise à jour d’un état de notification partagé.
**LWLock:AsyncQueueLock**
Un processus est en attente de lecture ou de mise à jour des messages de notification.
**LWLock:AuroraOptimizedReadsCacheMapping**
Un processus attend d’associer un bloc de données à une page dans le cache à plusieurs niveaux Optimized Reads.
**LWLock:AutoFile**
Un processus est en attente de mise à jour du fichier `postgresql.auto.conf`.
**LWLock:AutoFileLock**
Un processus est en attente de mise à jour du fichier `postgresql.auto.conf`.
**LWLock: Aspirateur automatique**
Un processus est en attente de lecture ou de mise à jour de l’état actuel des applications de travail d’autovacuum.
**LWLock:AutovacuumLock**
Une application de travail ou un lanceur d’applications d’autovacuum attend de mettre à jour ou de lire l’état actuel des applications de travail d’autovacuum.
**LWLock:AutovacuumSchedule**
Un processus est en attente pour s’assurer qu’une table sélectionnée pour l’autovacuum doit encore être vidée.
**LWLock:AutovacuumScheduleLock**
Un processus est en attente pour s’assurer que la table choisie pour un vidage doit encore être vidée.
**LWLock:BackendRandomLock**
Un processus est en attente pour générer un nombre aléatoire.
**LWLock:BackgroundWorker**
Un processus est en attente de lecture ou de mise à jour de l’état de l’application de travail en arrière-plan.
**LWLock:BackgroundWorkerLock**
Un processus est en attente de lecture ou de mise à jour de l’état de l’application de travail en arrière-plan.
**LWLock:BtreeVacuum**
Un processus est en attente de lecture ou de mise à jour des informations relatives au vide pour un index d’arborescence B.
**LWLock:BtreeVacuumLock**
Un processus est en attente de lecture ou de mise à jour des informations relatives au vide pour un index d’arborescence B.
**LWLock:contenu\$1du tampon**
Un processus dorsal attend d’acquérir un verrou léger sur le contenu d’un tampon de mémoire partagée. Pour de plus amples informations, veuillez consulter [LWLock:buffer\$1content () BufferContent](apg-waits.lockbuffercontent.md).
**LWLock:mappage\$1tampon**
Un processus dorsal attend d’associer un bloc de données à une mémoire tampon dans le groupe de mémoires tampons partagées. Pour de plus amples informations, veuillez consulter [LWLock:mappage\$1tampon](apg-waits.lwl-buffer-mapping.md).
**LWLock: BufferIO**
Un processus de backend souhaite lire une page en mémoire partagée. Le processus attend que les autres processus terminent leur tâche I/O pour la page. Pour de plus amples informations, veuillez consulter [LWLock:BufferIO (IPC:BufferIO)](apg-waits.lwlockbufferio.md).
**LWLock:Point de contrôle**
Un processus attend de commencer un point de contrôle.
**LWLock:CheckpointLock**
Un processus attend d’exécuter un point de contrôle.
**LWLock:CheckpointerComm**
Un processus attend de gérer les demandes `fsync`.
**LWLock:CheckpointerCommLock**
Un processus attend de gérer les demandes `fsync`.
**LWLock:sabot**
Un processus est en attente I/O dans une mémoire tampon obstruée (statut de transaction).
**LWLock:CLogControlLock**
Un processus attend de lire ou de mettre à jour l’état de la transaction.
**LWLock:CLogTruncationLock**
Un processus attend d’exécuter `txid_status` ou de mettre à jour l’ID de transaction le plus ancien disponible.
**LWLock:commit\$1timestamp**
Un processus est en attente I/O sur une mémoire tampon d'horodatage de validation.
**LWLock:CommitTs**
Un processus attend de lire ou de mettre à jour la dernière valeur définie pour un horodatage de validation de transaction.
**LWLock:CommitTsBuffer**
Un processus attend un horodatage de validation I/O sur un tampon simple utilisé le moins récemment (SLRU).
**LWLock:CommitTsControlLock**
Un processus attend de lire ou de mettre à jour les horodatages de validation de transactions.
**LWLock:CommitTsLock**
Un processus attend de lire ou de mettre à jour la dernière valeur définie pour l’horodatage de la transaction.
**LWLock: CommitTs SLRU**
Un processus attend d’accéder au cache simple le moins récemment utilisé (SLRU) pour un horodatage de livraison.
**LWLock:ControlFile**
Un processus attend de lire ou de mettre à jour le fichier `pg_control` ou de créer un nouveau fichier WAL.
**LWLock:ControlFileLock**
Un processus attend de lire ou de mettre à jour le fichier de contrôle ou de créer un nouveau fichier WAL.
**LWLock:DynamicSharedMemoryControl**
Un processus attend de lire ou de mettre à jour les informations d’allocation de mémoire partagée dynamique.
**LWLock:DynamicSharedMemoryControlLock**
Un processus attend de lire ou de mettre à jour l’état de la mémoire partagée dynamique.
**LWLock:lock\$1manager**
Un processus dorsal attend d’ajouter ou d’examiner des verrous pour les processus dorsal. Ou il attend de rejoindre ou de quitter un groupe de verrouillage utilisé par une requête parallèle. Pour de plus amples informations, veuillez consulter [LWLock:lock\$1manager](apg-waits.lw-lock-manager.md).
**LWLock:LockFastPath**
Un processus attend de lire ou de mettre à jour les informations de verrouillage du chemin d’accès rapide d’un processus.
**LWLock:LogicalRepWorker**
Un processus attend de lire ou de mettre à jour l’état des applications de travail de réplication logique.
**LWLock:LogicalRepWorkerLock**
Un processus attend la fin d’une action sur une application de travail de réplication logique.
**LWLock:LogicalSchemaCache**
Un processus a modifié le cache du schéma.
**LWLock:multixact\$1member**
Un processus est en attente I/O sur un tampon multixact\$1member.
**LWLock:multixact\$1offset**
Un processus est en attente I/O sur un tampon de décalage multixact.
**LWLock:MultiXactGen**
Un processus est en attente de lecture ou de mise à jour de l’état multixact partagé.
**LWLock:MultiXactGenLock**
Un processus est en attente de lecture ou de mise à jour d’un état multixact partagé.
**LWLock:MultiXactMemberBuffer**
Un processus est en attente I/O sur une mémoire tampon simple la moins récemment utilisée (SLRU) pour un membre multixact. Pour de plus amples informations, veuillez consulter [LWLock:MultiXact](apg-waits.lwlockmultixact.md).
**LWLock:MultiXactMemberControlLock**
Un processus est en attente de lecture ou de mise à jour des mappages de membres multixact.
**LWLock: MultiXactMember SLRU**
Un processus attend d’accéder au cache simple le moins récemment utilisé (SLRU) pour un membre multixact. Pour de plus amples informations, veuillez consulter [LWLock:MultiXact](apg-waits.lwlockmultixact.md).
**LWLock:MultiXactOffsetBuffer**
Un processus attend un décalage I/O multixact sur un tampon simple le moins récemment utilisé (SLRU). Pour de plus amples informations, veuillez consulter [LWLock:MultiXact](apg-waits.lwlockmultixact.md).
**LWLock:MultiXactOffsetControlLock**
Un processus est en attente de lecture ou de mise à jour des mappages de décalages multixact.
**LWLock: MultiXactOffset SLRU**
Un processus attend d’accéder au cache simple le moins récemment utilisé (SLRU) pour un décalage multixact. Pour de plus amples informations, veuillez consulter [LWLock:MultiXact](apg-waits.lwlockmultixact.md).
**LWLock:MultiXactTruncation**
Un processus attend de lire ou de tronquer des informations multixact.
**LWLock:MultiXactTruncationLock**
Un processus attend de lire ou de tronquer des informations multixact.
**LWLock:NotifyBuffer**
Un processus attend un message NOTIFY I/O sur la mémoire tampon la moins récemment utilisée (SLRU).
**LWLock:NotifyQueue**
Un processus est en attente de lecture ou de mise à jour des messages NOTIFY.
**LWLock:NotifyQueueTail**
Un processus attend de mettre à jour une limite sur le stockage des messages NOTIFY.
**LWLock:NotifyQueueTailLock**
Un processus attend de mettre à jour la limite de stockage des messages de notification.
**LWLock: Notifier SLRU**
Un processus attend d’accéder au cache simple le moins récemment utilisé (SLRU) pour un message NOTIFY.
**LWLock:OidGen**
Un processus attend d’allouer un nouvel ID d’objet (OID).
**LWLock:OidGenLock**
Un processus attend d’allouer ou d’affecter un nouvel ID d’objet (OID).
**LWLock:oldserxid**
Un processus est en attente I/O sur un tampon oldserxid.
**LWLock:OldSerXidLock**
Un processus attend de lire ou d’enregistrer des transactions sérialisables en conflit.
**LWLock:OldSnapshotTimeMap**
Un processus attend de lire ou de mettre à jour les anciennes informations de contrôle des instantanés.
**LWLock:OldSnapshotTimeMapLock**
Un processus attend de lire ou de mettre à jour les anciennes informations de contrôle des instantanés.
**LWLock:parallel\$1ajouter**
Un processus attend de choisir le sous-plan suivant lors de l’exécution du plan d’ajout parallèle.
**LWLock:parallel\$1hash\$1join**
Un processus attend d’allouer ou d’échanger un morceau de mémoire ou de mettre à jour des compteurs pendant l’exécution d’un plan de hachage parallèle.
**LWLock:parallel\$1query\$1dsa**
Un processus attend le verrouillage de l’allocation dynamique de mémoire partagée pour une requête parallèle.
**LWLock:ParallelAppend**
Un processus attend de choisir le sous-plan suivant lors de l’exécution du plan d’ajout parallèle.
**LWLock:ParallelHashJoin**
Un processus est en attente de synchronisation des applications de travail pendant l’exécution du plan pour une jointure de hachage parallèle.
**Lloque : DSA ParallelQuery**
Un processus attend une allocation dynamique de mémoire partagée pour une requête parallèle.
**Lloque : DSA PerSession**
Un processus attend une allocation dynamique de mémoire partagée pour une requête parallèle.
**Lloque : PerSessionRecordType**
Un processus attend d’accéder aux informations d’une requête parallèle sur les types composites.
**Lloque : PerSessionRecordTypmod**
Un processus attend d’accéder aux informations d’une requête parallèle sur les modificateurs de type qui identifient les types d’enregistrements anonymes.
**Lloque : PerXactPredicateList**
Un processus attend d’accéder à la liste des verrous de prédicats détenus par la transaction sérialisable en cours lors d’une requête parallèle.
**Lwlock:predicate\$1lock\$1manager**
Un processus attend d’ajouter ou d’examiner des informations de verrouillage du prédicat.
**Lloque : PredicateLockManager**
Un processus attend d’accéder aux informations de verrouillage des prédicats utilisées par les transactions sérialisables.
**Lwlock:proc**
Un processus attend de lire ou de mettre à jour les informations de verrouillage du chemin d’accès rapide.
**LWLock:ProcArray**
Un processus attend d’accéder aux structures de données partagées par processus (généralement pour obtenir un instantané ou signaler l’ID de transaction d’une session).
**LWLock:ProcArrayLock**
Un processus attend d’obtenir un instantané ou d’effacer un ID de transaction à la fin d’une transaction.
**LWLock:RelationMapping**
Un processus attend de lire ou de mettre à jour un fichier `pg_filenode.map` (utilisé pour suivre les affectations de nœuds de fichiers de certains catalogues système).
**LWLock:RelationMappingLock**
Un processus attend de mettre à jour le fichier de mappage des relations utilisé pour stocker le catalog-to-file-node mappage.
**LWLock:RelCacheInit**
Un processus attend de lire ou de mettre mise à jour un fichier `pg_internal.init` (fichier d’initialisation du cache de relation).
**LWLock:RelCacheInitLock**
Un processus attend de lire ou d’écrire un fichier d’initialisation du cache de relation.
**LWLock:origine de la réplication**
Un processus attend de lire ou de mettre à jour la progression de la réplication.
**LWLock:replication\$1slot\$1io**
Un processus est en attente I/O sur un emplacement de réplication.
**LWLock:ReplicationOrigin**
Un processus est en attente de création, de suppression ou d’utilisation d’une origine de réplication.
**LWLock:ReplicationOriginLock**
Un processus est en attente de configuration, de suppression ou d’utilisation d’une origine de réplication.
**LWLock:ReplicationOriginState**
Un processus attend de lire ou de mettre à jour la progression d’une origine de réplication.
**LWLock:ReplicationSlotAllocation**
Un processus attend d’allouer ou de libérer un emplacement de réplication.
**LWLock:ReplicationSlotAllocationLock**
Un processus attend d’allouer ou de libérer un emplacement de réplication.
**LWLock:ReplicationSlotControl**
Un processus attend de lire ou de mettre à jour un état d’emplacement de réplication.
**LWLock:ReplicationSlotControlLock**
Un processus attend de lire ou de mettre à jour l’état d’emplacement de réplication.
**LWLock: ReplicationSlot IO**
Un processus est en attente I/O sur un emplacement de réplication.
**LWLock:SerialBuffer**
Un processus attend un simple tampon utilisé I/O le moins récemment (SLRU) pour un conflit de transaction sérialisable.
**LWLock:SerializableFinishedList**
Un processus attend d’accéder à la liste des transactions sérialisables terminées.
**LWLock:SerializableFinishedListLock**
Un processus attend d’accéder à la liste des transactions sérialisables terminées.
**LWLock:SerializablePredicateList**
Un processus attend d’accéder à la liste des verrous de prédicats détenus par des transactions sérialisables.
**LWLock:SerializablePredicateLockListLock**
Un processus est en attente d’exécution d’une opération sur une liste de verrous détenus par des transactions sérialisables.
**LWLock:SerializableXactHash**
Un processus attend de lire ou de mettre à jour des informations sur les transactions sérialisables.
**LWLock:SerializableXactHashLock**
Un processus attend de récupérer ou de stocker des informations sur les transactions sérialisables.
**LWLock: Série SLRU**
Un processus attend d’accéder au cache simple le moins récemment utilisé (SLRU) pour un conflit de transaction sérialisable.
**LWLock:SharedTidBitmap**
Un processus attend d’accéder à un bitmap d’identifiant de tuple partagé (TID) lors d’une analyse d’index bitmap parallèle.
**LWLock:SharedTupleStore**
Un processus attend d’accéder à un magasin de tuples partagé lors d’une requête parallèle.
**LWLock:ShmemIndex**
Un processus attend de trouver ou d’allouer de l’espace dans la mémoire partagée.
**LWLock:ShmemIndexLock**
Un processus attend de trouver ou d’allouer de l’espace dans la mémoire partagée.
**LWLock: SInval Lisez**
Un processus attend de récupérer des messages de la file d’attente d’invalidation du catalogue partagé.
**LWLock:SInvalReadLock**
Un processus attend de récupérer ou de supprimer des messages d’une file d’attente d’invalidation partagée.
**LWLock: SInval Écrire**
Un processus attend d’ajouter un message à la file d’attente d’invalidation du catalogue partagé.
**LWLock:SInvalWriteLock**
Un processus attend d’ajouter un message dans une file d’attente d’invalidation partagée.
**LWLock:SyncRep**
Un processus attend de lire ou de mettre à jour des informations sur l’état de la réplication synchrone.
**LWLock:SyncRepLock**
Un processus attend de lire ou de mettre à jour des informations sur les réplicas synchrones.
**LWLock:SyncScan**
Un processus attend de sélectionner l’emplacement de début d’une analyse de table synchronisée.
**LWLock:SyncScanLock**
Un processus attend d’obtenir l’emplacement de début d’une analyse sur une table pour les analyses synchronisées.
**LWLock:TablespaceCreate**
Un processus est en attente de création ou de suppression d’un espace de table.
**LWLock:TablespaceCreateLock**
Un processus est en attente de création ou de suppression de l’espace de table.
**LWLock:tbm**
Un processus attend un verrou d’itérateur partagé sur un bitmap d’arborescence (TBM).
**LWLock:TwoPhaseState**
Un processus attend de lire ou de mettre à jour l’état des transactions préparées.
**LWLock:TwoPhaseStateLock**
Un processus attend de lire ou de mettre à jour l’état des transactions préparées.
**LWLock:wal\$1insert**
Un processus attend d’insérer le journal WAL dans un tampon de mémoire.
**LWLock: WALBuf Cartographie**
Un processus attend de remplacer une page dans les tampons WAL.
**LWLock:WALBufMappingLock**
Un processus attend de remplacer une page dans les tampons WAL.
**LWLock:WALInsert**
Un processus attend d’insérer les données WAL dans un tampon de mémoire.
**LWLock:WALWrite**
Un processus attend l’écriture de tampons WAL sur le disque.
**LWLock: WALWrite Verrouiller**
Un processus attend l’écriture de tampons WAL sur le disque.
**LWLock:WrapLimitsVacuum**
Un processus attend de mettre à jour les limites relatives à l’ID de transaction et à la consommation multixact.
**LWLock:WrapLimitsVacuumLock**
Un processus attend de mettre à jour les limites relatives à l’ID de transaction et à la consommation multixact.
**LWLock:XactBuffer**
Un processus attend l'état d'une transaction I/O sur une simple mémoire tampon utilisée le moins récemment (SLRU).
**LWLock:XactSLRU**
Un processus attend d’accéder au cache simple le moins récemment utilisé (SLRU) pour un état de transaction.
**LWLock:XactTruncation**
Un processus attend d’exécuter pg\$1xact\$1status ou de mettre à jour l’ID de transaction le plus ancien disponible.
**LWLock:XidGen**
Un processus attend d’allouer un nouvel ID de transaction.
**LWLock:XidGenLock**
Un processus attend d’allouer ou d’attribuer un ID de transaction.
**Délai d'expiration : BaseBackupThrottle**
Un processus est en attente pendant la sauvegarde de base lors de la limitation de l’activité.
**Délai d'expiration : PgSleep**
Un processus dorsal a appelé la fonction pg\$1sleep et attend l’expiration du délai de veille. Pour de plus amples informations, veuillez consulter [Timeout:PgSleep](apg-waits.timeoutpgsleep.md).
**Délai d'expiration : RecoveryApplyDelay**
Un processus attend d’appliquer le journal WAL pendant la restauration en raison d’un paramètre de retard.
**Délai d'expiration : RecoveryRetrieveRetryInterval**
Un processus est en attente pendant la récupération lorsque les données WAL ne sont disponibles à partir d’aucune source (pg\$1wal, archive ou flux).
**Délai d'expiration : VacuumDelay**
Un processus est en attente dans un délai de vide basé sur les coûts.
Pour obtenir la liste complète des événements d’attente PostgreSQL, consultez [The Statistics Collector > Wait Event tables](https://www.postgresql.org/docs/current/monitoring-stats.html#WAIT-EVENT-TABLE) dans la documentation de PostgreSQL.