# Referencia de Amazon Aurora PostgreSQL
En los siguientes temas, encontrará información sobre las intercalaciones, las funciones, los parámetros y los eventos de espera en Amazon Aurora PostgreSQL.
**Topics**
+ [Intercalaciones de Aurora PostgreSQL para EBCDIC y otras migraciones de mainframe](#AuroraPostgreSQL.Reference.Collations.mainframe.migration)
+ [Intercalaciones admitidas en Aurora PostgreSQL](PostgreSQL-Collations.md)
+ [Referencia de las funciones de Aurora PostgreSQL](Appendix.AuroraPostgreSQL.Functions.md)
+ [Parámetros de Amazon Aurora PostgreSQL.](AuroraPostgreSQL.Reference.ParameterGroups.md)
+ [Eventos de espera de Amazon Aurora PostgreSQL](AuroraPostgreSQL.Reference.Waitevents.md)
## Intercalaciones de Aurora PostgreSQL para EBCDIC y otras migraciones de mainframe
Migración de aplicaciones de mainframe a nuevas plataformas, como AWS conserva idealmente el comportamiento de las aplicaciones. Para preservar el comportamiento de las aplicaciones en una nueva plataforma exactamente igual que en el mainframe, se requiere que los datos migrados se recopilen utilizando las mismas reglas de intercalación y clasificación. Por ejemplo, muchas soluciones de migración de Db2 cambian los valores nulos a u0180 (posición Unicode 0180), por lo que estas intercalaciones clasifican u0180 primero. Este es un ejemplo de cómo las intercalaciones pueden variar de su fuente de mainframe y por qué es necesario elegir una intercalación que se adapte mejor a la intercalación EBCDIC original.
Aurora PostgreSQL 14.3 y versiones posteriores proporcionan muchas intercalaciones de ICU y EBCDIC para admitir dicha migración a AWS usando el servicio AWS Mainframe Modernization. Para obtener más información acerca de este servicio, consulte el tema sobre [qué es AWS Mainframe Modernization](https://docs.aws.amazon.com/m2/latest/userguide/what-is-m2.html).
En la siguiente tabla, encontrará intercalaciones provistas por Aurora PostgreSQL. Estas intercalaciones siguen las reglas de EBCDIC y garantizan que las aplicaciones de mainframe funcionen igual en AWS como en el entorno de mainframe. El nombre de la intercalación incluye la página de códigos correspondiente, (cp*nnnn*), para que pueda elegir la intercalación adecuada para su origen de mainframe. Por ejemplo, use `en-US-cp037-x-icu` para lograr el comportamiento de intercalación para los datos EBCDIC que se originaron en una aplicación de mainframe que utilizaba la página de códigos 037.
| Intercalaciones EBCDIC | Intercalaciones AWS Blu Age | Intercalaciones AWS Micro Focus |
| --- | --- | --- |
| da-DK-cp1142-x-icu | da-DK-cp1142m-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 | – |
Para obtener más información sobre AWS Blu Age, consulte el [tutorial sobre el tiempo de ejecución administrado para AWS Blu Age](https://docs.aws.amazon.com/m2/latest/userguide/tutorial-runtime-ba.html) en la *guía del usuario de AWS Mainframe Modernization*.
Para obtener información acerca del uso de AWS Micro Focus, consulte el [tutorial sobre el tiempo de ejecución administrado para Micro Focus](https://docs.aws.amazon.com/m2/latest/userguide/tutorial-runtime.html) en la *guía del usuario de AWS Mainframe Modernization*.
Para obtener más información sobre la administración de intercalaciones en PostgreSQL, consulte [compatibilidad de las intercalaciones](https://www.postgresql.org/docs/current/collation.html) en la documentación de PostgreSQL.
# Intercalaciones admitidas en Aurora PostgreSQL
Las intercalaciones son un conjunto de reglas que determinan cómo se ordenan y comparan las cadenas de caracteres almacenadas en la base de datos. Las intercalaciones desempeñan un papel fundamental en el sistema de computación y se incluyen como parte del sistema operativo. Las intercalaciones cambian con el tiempo cuando se añaden nuevos caracteres a los lenguajes o cuando cambian las reglas de ordenación.
Las bibliotecas de intercalaciones definen reglas y algoritmos específicos para una intercalación. Las bibliotecas de intercalaciones más populares utilizadas en PostgreSQL son GNU C (glibc) y los componentes de internacionalización de Unicode (ICU). De forma predeterminada, Aurora PostgreSQL utiliza la intercalación glibc, que incluye ordenaciones de caracteres Unicode para secuencias de caracteres de varios bytes.
Al crear un nuevo clúster de base de datos de Aurora PostgreSQL, se comprueba en el sistema operativo la intercalación disponible. Los parámetros de PostgreSQL del comando `CREATE DATABASE` `LC_COLLATE` y `LC_CTYPE` se utilizan para especificar una intercalación, que es la intercalación predeterminada en esa base de datos. Como alternativa, también puede utilizar el parámetro `LOCALE` en `CREATE DATABASE` para establecer estos parámetros. Esto determina la intercalación predeterminada de las cadenas de caracteres de la base de datos y las reglas para clasificar los caracteres como letras, números o símbolos. También puede elegir una intercalación para utilizarla en una columna, un índice o una consulta.
Aurora PostgreSQL depende de la biblioteca glibc del sistema operativo para admitir las intercalaciones. La instancia de Aurora PostgreSQL se actualiza periódicamente con las versiones más recientes del sistema operativo. Estas actualizaciones a veces incluyen una versión más reciente de la biblioteca glibc. En raras ocasiones, las versiones más recientes de glibc cambian la ordenación o la intercalación de algunos caracteres, lo que puede provocar que los datos se ordenen de forma diferente o generar entradas de índice no válidas. Si durante una actualización detecta problemas de ordenación para la intercalación, es posible que tenga que volver a generar los índices.
Para reducir el posible impacto de las actualizaciones de glibc, Aurora PostgreSQL incluye ahora una biblioteca de intercalaciones predeterminada independiente. Esta biblioteca de intercalaciones está disponible en Aurora PostgreSQL 14.6, 13.9, 12.13, 11.18 y versiones secundarias posteriores. Es compatible con glibc 2.26-59.amzn2 y proporciona estabilidad en la ordenación para evitar resultados de consultas incorrectos.
# Referencia de las funciones de Aurora PostgreSQL
A continuación, encontrará una lista de las funciones de Aurora PostgreSQL disponibles para los clústeres de base de datos de Aurora que ejecutan el motor de base de datos de edición compatible con Aurora PostgreSQL. Estas funciones de Aurora PostgreSQL se suman a las funciones estándar de PostgreSQL. Para obtener más información acerca de las funciones estándar de PostgreSQL, consulte [PostgreSQL: funciones y operadores](https://www.postgresql.org/docs/current/functions.html).
## Descripción general
Puede utilizar las siguientes funciones para instancias de base de datos de Amazon RDS que ejecutan 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
Informa del nombre de la instancia de base de datos a la que está conectado.
## Sintaxis
```
aurora_db_instance_identifier()
```
## Argumentos
Ninguno
## Tipo de retorno
Cadena VARCHAR
## Notas de uso
Esta función muestra el nombre de la instancia de base de datos del clúster de Aurora PostgreSQL-Compatible Edition para su conexión de aplicaciones o cliente de base de datos.
Esta función está disponible desde el lanzamiento de las versiones 13.7, 12.11, 11.16 y 10.21 de Aurora PostgreSQL, y para todas las demás versiones posteriores.
## Ejemplos
En el ejemplo siguiente se muestra lo que ocurre al llamar a la función `aurora_db_instance_identifier`.
```
=> SELECT aurora_db_instance_identifier();
aurora_db_instance_identifier
-------------------------------
test-my-instance-name
```
Puede unir los resultados de esta función con la función `aurora_replica_status` para obtener detalles sobre la instancia de base de datos de la conexión. [aurora\$1replica\$1status](aurora_replica_status.md) sola no muestra qué instancia de base de datos está utilizando. El siguiente ejemplo muestra cómo.
```
=> 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
Muestra el estado del administrador de caché del clúster.
## Sintaxis
```
aurora_ccm_status()
```
## Argumentos
Ninguna.
## Tipo de retorno
Registro SETOF con las siguientes columnas:
+ `buffers_sent_last_minute`: el número de búferes enviados al lector designado en el último minuto.
+ `buffers_found_last_minute`: el número de búferes de acceso frecuente identificados durante el último minuto.
+ `buffers_sent_last_scan`: la cantidad de búferes enviados al lector designado durante el último análisis completo de la caché del búfer.
+ `buffers_found_last_scan`: el número de búferes de acceso frecuente enviados durante la última exploración completa de la caché del búfer. Los búferes que ya están almacenados en la caché en el lector designado no se envían.
+ `buffers_sent_current_scan`: el número de búferes enviados durante el análisis actual.
+ `buffers_found_current_scan`: el número de búferes de acceso frecuente identificados en el análisis actual.
+ `current_scan_progress`: el número de búferes visitados hasta el momento durante el análisis actual.
## Notas de uso
Puede utilizar esta función para comprobar y supervisar la función de administración de caché del clúster (CCM). Esta función solo funciona si CCM está activo en el clúster de base de datos Aurora PostgreSQL. Para utilizar esta función, conéctese a la instancia de base de datos de escritura del clúster de base de datos Aurora PostgreSQL.
Puede activar CCM para un clúster de base de datos Aurora PostgreSQL configurando `apg_ccm_enabled` en 1 del grupo de parámetros del clúster de base de datos personalizado del clúster. Para aprender a hacerlo, consulte [Configuración de la administración de la caché del clúster](AuroraPostgreSQL.cluster-cache-mgmt.md#AuroraPostgreSQL.cluster-cache-mgmt.Configure).
La administración de caché de clúster está activa en un clúster de base de datos Aurora PostgreSQL cuando el clúster tiene una instancia de Aurora Reader configurada de la siguiente forma:
+ La instancia de Aurora Reader utiliza el mismo tipo y tamaño de clase de instancia de base de datos que la instancia Writer del clúster.
+ La instancia de Aurora Reader se configura como nivel 0 para el clúster. Si el clúster tiene más de un lector, este es su único lector de nivel 0.
Al configurar más de un lector en el nivel 0, se deshabilita CCM. Cuando CCM está deshabilitado, al llamar a esta función se devuelve el siguiente mensaje de error:
```
ERROR: Cluster Cache Manager is disabled
```
También puede utilizar la extensión pg\$1buffercache de PostgreSQL para analizar la caché del búfer. Para obtener más información consulte [pg\$1buffercache](https://www.postgresql.org/docs/current/pgbuffercache.html), en la documentación de PostgreSQL.
Para obtener más información, consulte [Introducción a la administración de caché de clúster de Aurora PostgreSQL](https://aws.amazon.com/blogs/database/introduction-to-aurora-postgresql-cluster-cache-management/).
## Ejemplos
En el ejemplo siguiente se muestran los resultados de llamar a la función `aurora_ccm_status`. En este primer ejemplo se muestran las estadísticas de 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
```
Para obtener más detalles, puede utilizar la pantalla ampliada, como se muestra a continuación:
```
\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
```
En este ejemplo se muestra cómo comprobar la tasa de calentamiento y el porcentaje de calentamiento.
```
=> 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
Muestra el estado de todas las instancias de Aurora, incluidas las réplicas de un clúster de base de datos global de Aurora.
## Sintaxis
```
aurora_global_db_instance_status()
```
## Argumentos
Ninguno
## Tipo de retorno
Registro SETOF con las siguientes columnas:
+ `server_id`: el identificador de la instancia de base de datos.
+ `session_id`: un identificador único de la sesión actual. Un valor `MASTER_SESSION_ID` identifica la instancia de base de datos de Writer (principal).
+ `aws_region`: la Región de AWS en la que se ejecuta esta instancia de base de datos global. Para obtener una lista de regiones, consulte [Disponibilidad por región](Concepts.RegionsAndAvailabilityZones.md#Aurora.Overview.Availability).
+ `durable_lsn`: el número de secuencia de registro (LSN) hecho duradero en el almacenamiento. Un número de secuencia de registro (LSN) es un número secuencial único que identifica un registro en el registro de transacciones de la base de datos. Los LSN se ordenan de tal manera que un LSN más grande representa una transacción posterior.
+ `highest_lsn_rcvd`: LSN más alto recibido por la instancia de base de datos de la instancia de base de datos de escritor.
+ `feedback_epoch`: fecha de inicio que utiliza la instancia de base de datos cuando genera información en espera activa. Una *espera activa* es una instancia de base de datos que admite conexiones y consultas mientras la base de datos principal está en modo de recuperación o espera. La información de espera activa incluye la época (punto en el tiempo) y otros detalles sobre la instancia de base de datos que se utiliza como reserva activa. Para obtener más información, consulte la documentación de PostgreSQL sobre [Espera activa](https://www.postgresql.org/docs/current/hot-standby.html).
+ `feedback_xmin`: ID de transacción activo mínimo (más antiguo) utilizado por la instancia de base de datos.
+ `oldest_read_view_lsn`: LSN más antiguo utilizado por la instancia de base de datos para leer desde el almacenamiento.
+ `visibility_lag_in_msec`: tiempo que esta instancia de base de datos se está quedando por detrás de la instancia de base de datos de escritor en milisegundos.
## Notas de uso
Esta función muestra estadísticas de replicación para un clúster de base de datos Aurora. Para cada instancia de base de datos Aurora PostgreSQL del clúster, la función muestra una fila de datos que incluye cualquier réplica entre regiones en una configuración de base de datos global.
Puede ejecutar esta función desde cualquier instancia de un clúster de base de datos Aurora PostgreSQL o una base de datos global de Aurora PostgreSQL. La función devuelve detalles sobre el retraso de todas las instancias de réplica.
Para obtener más información sobre el retraso de la supervisión mediante esta función (`aurora_global_db_instance_status`) o utilizando `aurora_global_db_status`, consulte[Supervisión de bases de datos globales basadas en Aurora PostgreSQL](aurora-global-database-monitoring.md#aurora-global-database-monitoring.postgres).
Para obtener información sobre las bases de datos globales de Aurora, consulte [Información general sobre la base de datos global de Amazon Aurora](aurora-global-database.md#aurora-global-database-overview).
Para empezar a utilizar bases de datos globales de Aurora, consulte [Introducción a la base de datos global de Amazon Aurora](aurora-global-database-getting-started.md) o consulte [Preguntas frecuentes de Amazon Aurora](https://aws.amazon.com/rds/aurora/faqs/).
## Ejemplos
En este ejemplo se muestran estadísticas de instancias entre regiones.
```
=> 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
```
En este ejemplo se muestra cómo comprobar el retraso de réplica global en milisegundos.
```
=> 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
```
En este ejemplo se muestra cómo comprobar el retraso mínimo, máximo y medio por Región de AWS desde la configuración de base de datos global.
```
=> 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
Muestra información sobre varios aspectos del retardo de la base de datos global de Aurora, específicamente, el retardo del almacenamiento de Aurora subyacente (llamado retardo de durabilidad) y el retardo entre el objetivo de punto de recuperación (RPO).
## Sintaxis
```
aurora_global_db_status()
```
## Argumentos
Ninguna.
## Tipo de retorno
Registro SETOF con las siguientes columnas:
+ `aws_region`: la Región de AWS donde está este clúster de base de datos. Para ver una lista completa de Regiones de AWS por motor, consulte [Regiones y zonas de disponibilidad](Concepts.RegionsAndAvailabilityZones.md).
+ `highest_lsn_written`: el número de secuencia de registro (LSN) más alto que existe actualmente en este clúster de base de datos. Un número de secuencia de registro (LSN) es un número secuencial único que identifica un registro en el registro de transacciones de la base de datos. Los LSN se ordenan de tal manera que un LSN más grande representa una transacción posterior.
+ `durability_lag_in_msec`: la diferencia en los valores de marca temporal entre el `highest_lsn_written` de un clúster de base de datos secundario y el `highest_lsn_written` del clúster de base de datos principal. Un valor de -1 identifica el clúster de base de datos principal de una base de datos global de Aurora.
+ `rpo_lag_in_msec`: el retraso del objetivo de punto de recuperación (RPO). El retardo de RPO es el tiempo que tarda la transacción de usuario más reciente en almacenarse en un clúster de base de datos secundario después de almacenarse en el clúster de base de datos principal de una base de datos global de Aurora. Un valor de -1 indica el clúster de base de datos principal (y, por lo tanto, el retardo no es relevante).
En términos sencillos, esta métrica calcula el objetivo del punto de recuperación de cada clúster de base de datos de Aurora PostgreSQL de una base de datos global de Aurora, es decir, cuántos datos podrían perderse si se produce una interrupción. Al igual que con el retraso, el RPO se mide en tiempo.
+ `last_lag_calculation_time`: la marca temporal que especifica cuándo se calcularon por última vez los valores para `durability_lag_in_msec` y `rpo_lag_in_msec`. Un valor temporal como `1970-01-01 00:00:00+00` significa que este es el clúster de base de datos principal.
+ `feedback_epoch`: la fecha de inicio que el clúster de base de datos secundario usa cuando genera información en espera activa. Una *espera activa* es una instancia de base de datos que admite conexiones y consultas mientras la base de datos principal está en modo de recuperación o espera. La información de espera activa incluye la época (punto en el tiempo) y otros detalles sobre la instancia de base de datos que se utiliza como reserva activa. Para obtener más información, consulte la documentación de PostgreSQL sobre [Espera activa](https://www.postgresql.org/docs/current/hot-standby.html).
+ `feedback_xmin`: el ID de transacción activa mínima (más antigua) utilizada por el clúster de base de datos secundario.
## Notas de uso
Esta función es compatible con todas las versiones de Aurora PostgreSQL disponibles actualmente. Esta función muestra estadísticas de replicación para una base de datos global de Aurora. Muestra una fila para cada clúster de base de datos de una base de datos global Aurora PostgreSQL. Puede ejecutar esta función desde cualquier instancia de una base de datos global de Aurora PostgreSQL.
Para evaluar el retraso de replicación de la base de datos global de Aurora, que es el retraso visible de los datos, consulte [aurora\$1global\$1db\$1instance\$1status](aurora_global_db_instance_status.md).
Para obtener más información sobre el uso de `aurora_global_db_status` y `aurora_global_db_instance_status` para supervisar el retraso global de la base de datos Aurora, consulte [Supervisión de bases de datos globales basadas en Aurora PostgreSQL](aurora-global-database-monitoring.md#aurora-global-database-monitoring.postgres). Para obtener información sobre las bases de datos globales de Aurora, consulte [Información general sobre la base de datos global de Amazon Aurora](aurora-global-database.md#aurora-global-database-overview).
## Ejemplos
En este ejemplo se muestra cómo visualizar estadísticas de almacenamiento entre regiones.
```
=> 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
Enumera todas las funciones incorporadas de Aurora PostgreSQL disponibles, junto con descripciones breves y detalles de funciones.
## Sintaxis
```
aurora_list_builtins()
```
## Argumentos
Ninguno
## Tipo de retorno
Registro SETOF
## Ejemplos
En el ejemplo siguiente se muestran los resultados de llamar a la función `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
Muestra el estado de todos los nodos de lector de Aurora PostgreSQL.
## Sintaxis
```
aurora_replica_status()
```
## Argumentos
Ninguno
## Tipo de retorno
Registro SETOF con las siguientes columnas:
+ `server_id`: identificador de la instancia de base de datos.
+ `session_id`: un identificador único para la sesión actual, devuelto para la instancia principal y las instancias de lectura de la siguiente manera:
+ Para la instancia principal, `session_id` es siempre ``MASTER_SESSION_ID’`.
+ Para instancias de lectura, `session_id` es siempre el `UUID` (identificador único universal) de la instancia de lector.
+ `durable_lsn`: número de secuencia de registro (LSN) que se guarda en el almacenamiento.
+ Para el volumen principal, es el LSN duradero del volumen (VDL) principal efectivo actualmente.
+ Para cualquier volumen secundario, es el VDL principal al que se ha aplicado correctamente el secundario.
**nota**
Un número de secuencia de registro (LSN) es un número secuencial único que identifica un registro en el registro de transacciones de la base de datos. Los LSN se ordenan de tal manera que un LSN más grande representa una transacción que ha tenido lugar más tarde en la secuencia.
+ `highest_lsn_rcvd`: LSN más alto (más reciente) recibido por la instancia de base de datos de la instancia de base de datos de escritor.
+ `current_read_lsn`: LSN de la instantánea más reciente que se ha aplicado a todos los lectores.
+ `cur_replay_latency_in_usec`: número de microsegundos que se espera que tarden en reproducir el registro en el secundario.
+ `active_txns`: número de transacciones activas actualmente.
+ `is_current`: no se usa.
+ `last_transport_error`: último código de error de replicación.
+ `last_error_timestamp`: marca temporal del último error de replicación.
+ `last_update_timestamp`: marca temporal de la última actualización del estado de la réplica. En Aurora PostgreSQL 13.9, el valor `last_update_timestamp` de la instancia de base de datos a la que está conectado se establece en `NULL`.
+ `feedback_xmin`: la espera activa feedback\$1xmin de la réplica. ID de transacción activo mínimo (más antiguo) utilizado por la instancia de base de datos.
+ `feedback_epoch`: fecha de inicio que utiliza la instancia de base de datos cuando genera información en espera activa.
+ `replica_lag_in_msec`: tiempo en que esa instancia de lector se queda detrás de la instancia de escritor, en milisegundos.
+ `log_stream_speed_in_kib_per_second`: rendimiento del flujo de registro en kilobytes por segundo.
+ `log_buffer_sequence_number`: número de secuencia de búfer de registro.
+ `oldest_read_view_trx_id`: no se usa.
+ `oldest_read_view_lsn`: LSN más antiguo utilizado por la instancia de base de datos para leer desde el almacenamiento.
+ `pending_read_ios`: lecturas de la página pendientes que aún deben replicarse.
+ `read_ios`: número total de lecturas de página en la réplica.
+ `iops`: no se usa.
+ `cpu`: Uso de la CPU del daemon de almacenamiento de Aurora para cada nodo del clúster. Para obtener más información acerca del uso de CPU por parte de la instancia, consulte [Métricas de nivel de instancia para Amazon Aurora](Aurora.AuroraMonitoring.Metrics.md#Aurora.AuroraMySQL.Monitoring.Metrics.instances).
## Notas de uso
Esta función es compatible con todas las versiones de Aurora PostgreSQL disponibles actualmente. La función `aurora_replica_status` devuelve valores del gestor de estado de réplica de un clúster de base de datos de Aurora PostgreSQL. Puede utilizar esta función para obtener información sobre el estado de la replicación en el clúster de base de datos de Aurora PostgreSQL, incluidas las métricas de todas las instancias de base de datos del clúster de base de datos de Aurora. Por ejemplo, puede hacer lo siguiente:
+ **Obtenga información sobre el tipo de instancia (escritor, lector) en el clúster de base de datos de Aurora PostgreSQL**: puede obtener esta información comprobando los valores de las columnas siguientes:
+ `server_id`: contiene el nombre de la instancia especificada cuando creó la instancia. En algunos casos, como para la instancia principal (escritor), el nombre se crea normalmente anexando *-instance-1* al nombre que cree para su clúster de base de datos de Aurora PostgreSQL.
+ `session_id`: el campo `session_id` indica si la instancia es un lector o un escritor. Para una instancia de escritor, `session_id` está siempre configurado en `"MASTER_SESSION_ID"`. Para una instancia de lector, `session_id` está configurado con el `UUID` del lector específico.
+ **Diagnosticar problemas de replicación comunes, como un retraso de réplica**: el retraso de réplica es el tiempo en milisegundos que la caché de página de una instancia de lector está por detrás del de la instancia de escritor. Este retraso se produce porque los clústeres de Aurora utilizan replicación asíncrona, tal como se describe en [Replicación con Amazon Aurora](Aurora.Replication.md). Se muestra en la columna `replica_lag_in_msec` en los resultados devueltos por esta función. El retraso también puede producirse cuando se cancela una consulta debido a conflictos con la recuperación en un servidor en espera. Puede comprobar `pg_stat_database_conflicts()` para verificar que dicho conflicto está provocando el retraso de la réplica (o no). Para obtener más información, consulte el tema sobre el [recopilador de estadísticas](https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-DATABASE-CONFLICTS-VIEW) en la *documentación de PostgreSQL*. Para obtener más información acerca de la alta disponibilidad y la replicación, consulte la sección de [Preguntas frecuentes de Amazon Aurora](https://aws.amazon.com/rds/aurora/faqs/#High_Availability_and_Replication).
Amazon CloudWatch almacena los resultados de `replica_lag_in_msec` a lo largo del tiempo, como la métrica `AuroraReplicaLag`. Para obtener más información acerca de las métricas de CloudWatch para Aurora, consulte [Supervisión de métricas de Amazon Aurora con Amazon CloudWatch](monitoring-cloudwatch.md).
Para obtener más información sobre la solución de problemas de réplicas de lectura y reinicios de Aurora, consulte la pregunta sobre [¿por qué mi réplica de lectura de Amazon Aurora se quedó atrás y se reinició?](https://aws.amazon.com/premiumsupport/knowledge-center/aurora-read-replica-restart/) en el [AWS SupportCenter](https://console.aws.amazon.com/support/home#/).
## Ejemplos
En el siguiente ejemplo se muestra cómo obtener el estado de replicación de todas las instancias de un clúster de base de datos de Aurora PostgreSQL:
```
=> SELECT *
FROM aurora_replica_status();
```
En el ejemplo siguiente se muestra la instancia de escritor en el clúster de base de datos de 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
```
En el ejemplo siguiente se enumeran todas las instancias de lector de un clúster:
```
=> 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)
```
En el siguiente ejemplo se enumeran todas las instancias, hasta qué punto está rezagada cada instancia con respecto al escritor y cuánto tiempo ha pasado desde la última actualización:
```
=> 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
Devuelve una fila por proceso del servidor, que muestra información relacionada con la actividad actual de ese proceso.
## Sintaxis
```
aurora_stat_activity();
```
## Argumentos
Ninguno
## Tipo de retorno
Devuelve una fila por proceso de servidor. Además de las columnas `pg_stat_activity`, se agrega el siguiente campo:
+ planid - identificador del plan
## Notas de uso
Una vista complementaria de `pg_stat_activity` devolviendo las mismas columnas con una columna `plan_id` adicional que muestra el plan de ejecución de la consulta actual.
`aurora_compute_plan_id` debe estar activado para que la vista devuelva un plan\$1id.
Esta función está disponible desde Aurora PostgreSQL versiones 14.10, 15.5, y para todas las demás versiones posteriores.
## Ejemplos
El ejemplo de consulta que aparece a continuación agrega la carga superior mediante query\$1id y 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 el plan utilizado para query\$1id cambia, aurora\$1stat\$1activity indicará un nuevo plan\$1id.
```
count | query_id | plan_id
-------+----------------------+-------------
10 | -5471422286312252535 | 1602979607
1 | -6907107586630739258 | -1809935983
1 | -2446282393000597155 | -207532066
(3 rows)
```
# aurora\$1stat\$1backend\$1waits
Muestra estadísticas de la actividad de espera de un proceso de backend específico.
## Sintaxis
```
aurora_stat_backend_waits(pid)
```
## Argumentos
`pid`: el ID del proceso de backend. Puede obtener los ID de proceso mediante la vista de `pg_stat_activity`.
## Tipo de retorno
Registro SETOF con las siguientes columnas:
+ `type_id`: un número que indica el tipo de evento de espera, como `1` para un bloqueo ligero (`LWLock`), `3` para un bloqueo o `6` para una sesión de cliente, por nombrar algunos ejemplos. Estos valores se vuelven significativos cuando se unen los resultados de esta función con columnas de la función `aurora_stat_wait_type`, tal y como se muestra en los [Ejemplos](#aurora_stat_backend_waits-examples).
+ `event_id`: número de identificación del evento de espera. Una este valor con las columnas de `aurora_stat_wait_event` para obtener nombres de eventos significativos.
+ `waits`: recuento del número de esperas acumuladas para el ID del proceso especificado.
+ `wait_time`: tiempo de espera en milisegundos.
## Notas de uso
Puede utilizar esta función para analizar eventos de espera específicos de backend (sesión) ocurridos desde que se abrió una conexión. Para obtener información más significativa sobre los nombres y tipos de eventos de espera, puede combinar esta función `aurora_stat_wait_type` y `aurora_stat_wait_event`, utilizando JOIN como se muestra en los ejemplos.
## Ejemplos
En este ejemplo se muestran todas las esperas, tipos y nombres de eventos de un ID de proceso 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
```
En este ejemplo se muestran los tipos de espera actuales y acumulados y los eventos de espera de todas las sesiones activas (`pg_stat_activity state <> 'idle'`) (pero sin la sesión actual que invoca la función (`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
```
En este ejemplo se muestran los tres (3) eventos de tipo de espera acumulativos y de espera principales para todas las sesiones activas (`pg_stat_activity state <> 'idle'`) excluyendo la sesión actual (`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` es una vista de estadísticas que muestra información sobre las lecturas optimizadas y las escrituras en caché.
## Sintaxis
```
aurora_stat_bgwriter()
```
## Argumentos
Ninguno
## Tipo de retorno
Registro SETOF con todas las columnas `pg_stat_bgwriter` y las siguientes columnas adicionales. Para obtener más información sobre las columnas `pg_stat_bgwriter`, consulte [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).
Puede restablecer las estadísticas de esta función utilizando `pg_stat_reset_shared("bgwriter")`.
+ `orcache_blks_written`: número total de lecturas optimizadas escritas en caché y bloques de datos.
+ `orcache_blk_write_time`: si se habilita `track_io_timing`, se registra el tiempo total dedicado a escribir lecturas optimizadas en bloques de archivos de datos de caché, en milisegundos. Para obtener más información, consulte [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
## Notas de uso
Esta función está disponible en las siguientes versiones de Aurora PostgreSQL:
+ Versión 15.4 y versiones posteriores a la 15
+ Versión 14.9 y versiones posteriores a la 14
## Ejemplos
```
=> select * from aurora_stat_bgwriter();
-[ RECORD 1 ]-----------------+-----------
orcache_blks_written | 246522
orcache_blk_write_time | 339276.404
```
# aurora\$1stat\$1database
Contiene todas las columnas de pg\$1stat\$1database y, al final, añade nuevas columnas.
## Sintaxis
```
aurora_stat_database()
```
## Argumentos
Ninguno
## Tipo de retorno
Registro SETOF con todas las columnas `pg_stat_database` y las siguientes columnas adicionales. Para obtener más información sobre las columnas `pg_stat_database`, consulte [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`: número total de bloques compartidos leídos desde el almacenamiento de Aurora en esta base de datos.
+ `orcache_blks_hit`: número total de visitas a la caché de lecturas optimizadas de esta base de datos.
+ `local_blks_read`: número total de bloques locales leídos en esta base de datos.
+ `storage_blk_read_time`: si se habilita `track_io_timing`, se registra el tiempo total dedicado a leer bloques de archivos de datos desde el almacenamiento de Aurora (en milisegundos); de lo contrario, el valor es cero. Para obtener más información, consulte [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
+ `local_blk_read_time`: si se habilita `track_io_timing`, se registra el tiempo total dedicado a leer bloques de archivos de datos locales, en milisegundos; de lo contrario, el valor es cero. Para obtener más información, consulte [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
+ `orcache_blk_read_time`: si se habilita `track_io_timing`, se registra el tiempo total dedicado a leer bloques de archivos de datos desde la caché de lecturas optimizadas (en milisegundos); de lo contrario, el valor es cero. Para obtener más información, consulte [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
**nota**
El valor de `blks_read` es la suma de`storage_blks_read` `orcache_blks_hit` y `local_blks_read`.
El valor de `blk_read_time` es la suma de`storage_blk_read_time` `orcache_blk_read_time` y `local_blk_read_time`.
## Notas de uso
Esta función está disponible en las siguientes versiones de Aurora PostgreSQL:
+ Versión 15.4 y versiones posteriores a la 15
+ Versión 14.9 y versiones posteriores a la 14
## Ejemplos
El siguiente ejemplo muestra cómo incluye todas las columnas `pg_stat_database` y añade 6 columnas nuevas al final:
```
=> 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
Informa la actividad acumulativa para cada tipo de operación de lenguaje de manipulación de datos (DML) en una base de datos en un clúster de Aurora PostgreSQL.
## Sintaxis
```
aurora_stat_dml_activity(database_oid)
```
## Argumentos
*database\$1oid*
ID de objeto (OID) de la base de datos en el clúster de Aurora PostgreSQL.
## Tipo de retorno
Registro SETOF
## Notas de uso
La función `aurora_stat_dml_activity` solo está disponible con Aurora PostgreSQL versión 3.1 compatible con el motor de PostgreSQL 11.6 y versiones posteriores.
Utilice esta función en clústeres de Aurora PostgreSQL con un gran número de bases de datos para identificar qué bases de datos tienen más actividad DML o más lenta, o ambas.
La función `aurora_stat_dml_activity` devuelve el número de veces que se ejecutaron las operaciones y la latencia acumulada en microsegundos para las operaciones SELECT, INSERT, UPDATE y DELETE. El informe solo incluye operaciones DML correctas.
Puede restablecer esta estadística mediante la función de acceso a estadísticas de PostgreSQL `pg_stat_reset`. Puede comprobar la última vez que se restableció esta estadística mediante la opción de función `pg_stat_get_db_stat_reset_time`. Para obtener más información acerca de las funciones de acceso a las estadísticas de PostgreSQL, consulte [Recopilador de estadísticas](https://www.postgresql.org/docs/9.1/monitoring-stats.html) en la documentación de PostgreSQL.
## Ejemplos
En el siguiente ejemplo se muestra cómo informar de las estadísticas de actividad de DML para la base de datos conectada.
```
––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
```
En el ejemplo siguiente se muestran las estadísticas de actividad de DML para todas las bases de datos del clúster de Aurora PostgreSQL. Este clúster tiene dos bases de datos: `postgres` y `mydb`. La lista separada por comas corresponde a los campos `select_count`, `select_latency_microsecs`, `insert_count`, `insert_latency_microsecs`, `update_count`, `update_latency_microsecs`, `delete_count` y `delete_latency_microsecs`.
Aurora PostgreSQL crea y utiliza una base de datos del sistema llamada `rdsadmin` para admitir operaciones administrativas como copias de seguridad, restauraciones, comprobaciones de estado, replicación, etc. Estas operaciones DML no tienen ningún impacto en su clúster de 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)
```
En el siguiente ejemplo se muestran las estadísticas de actividad de DML para todas las bases de datos, organizadas en columnas para una mejor legibilidad.
```
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
```
En el ejemplo siguiente se muestra la latencia acumulativa media (latencia acumulada dividida por recuento) para cada operación DML de la base de datos con el 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
Obtiene la latencia de confirmación acumulada en microsegundos para las bases de datos de Aurora PostgreSQL. *La latencia de confirmación* se mide como el tiempo transcurrido entre el momento en que un cliente envía una solicitud de confirmación y el momento en que recibe el acuse de recibo de confirmación.
## Sintaxis
```
aurora_stat_get_db_commit_latency(database_oid)
```
## Argumentos
*database\$1oid*
ID de objeto (OID) de la base de datos de Aurora PostgreSQL.
## Tipo de retorno
Registro SETOF
## Notas de uso
Amazon CloudWatch utiliza esta función para calcular la latencia media de confirmación. Para obtener más información acerca de las métricas de Amazon CloudWatch y cómo solucionar problemas de latencia de confirmación alta, consulte [Consulta de métricas en la consola de Amazon RDS](USER_Monitoring.md) y [Cómo tomar mejores decisiones sobre Amazon RDS con las métricas de Amazon CloudWatch](https://aws.amazon.com/blogs/database/making-better-decisions-about-amazon-rds-with-amazon-cloudwatch-metrics/).
Puede restablecer esta estadística mediante la función de acceso a estadísticas de PostgreSQL `pg_stat_reset`. Puede comprobar la última vez que se restableció esta estadística mediante la opción de función `pg_stat_get_db_stat_reset_time`. Para obtener más información acerca de las funciones de acceso a las estadísticas de PostgreSQL, consulte [Recopilador de estadísticas](https://www.postgresql.org/docs/9.1/monitoring-stats.html) en la documentación de PostgreSQL.
## Ejemplos
En el siguiente ejemplo se obtiene la latencia de confirmación acumulada de cada base de datos del clúster.`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
```
En el siguiente ejemplo se obtiene la latencia de confirmación acumulativa de la base de datos conectada actualmente. Antes de llamar al método `aurora_stat_get_db_commit_latency`, el ejemplo primero usa `\gset` para definir una variable para el argumento `oid` y establece su valor desde la base de datos conectada.
```
––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
```
En el siguiente ejemplo se obtiene la latencia de confirmación acumulada para la base de datos `mydb` en el clúster `pg_database`. A continuación, se restablece esta estadística mediante la función `pg_stat_reset` y muestra los resultados. Por último, utiliza el rol `pg_stat_get_db_stat_reset_time` para comprobar la última vez que se restableció esta estadística.
```
=> 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
Se muestra el uso de la caché del registro de escritura (WAL) lógica por ranura.
## Sintaxis
```
SELECT * FROM aurora_stat_logical_wal_cache()
```
## Argumentos
Ninguno
## Tipo de retorno
Registro SETOF con las siguientes columnas:
+ `name`: el nombre de la ranura de replicación.
+ `active_pid`: el identificador del proceso walsender.
+ `cache_hit`: el número total de aciertos de caché de wal desde el último restablecimiento.
+ `cache_miss`: el número total de fallos de caché de wal desde el último restablecimiento.
+ `blks_read`: el número total de solicitudes de lectura de la caché de wal.
+ `hit_rate`: la tasa de aciertos de caché de WAL (cache\$1hit/blks\$1read).
+ `last_reset_timestamp`: la última vez que se restableció el contador.
## Notas de uso
Esta función está disponible para las siguientes versiones de Aurora PostgreSQL:
+ Versiones 15.2 y posteriores
+ Versión 14.7 y posteriores
+ Versión 13.8 y posteriores
+ Versión 12.12 y posteriores
+ Versión 11.17 y posteriores
## Ejemplos
En el siguiente ejemplo, se muestran dos ranuras de replicación con una sola función `aurora_stat_logical_wal_cache` activa.
```
=> 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
Informa del uso del contexto de memoria para cada proceso de PostgreSQL.
## Sintaxis
```
aurora_stat_memctx_usage()
```
## Argumentos
Ninguno
## Tipo de retorno
Registro SETOF con las siguientes columnas:
+ `pid`: el ID del proceso.
+ `name`: el nombre del contexto.
+ `allocated`: el número de bytes obtenidos del subsistema de memoria subyacente por el contexto de memoria.
+ `used`: el número de bytes asignados a los clientes del contexto de memoria.
+ `instances`: el recuento de contextos de este tipo existentes actualmente.
## Notas de uso
Esta función muestra el uso del contexto de memoria para cada proceso de PostgreSQL. Algunos procesos están etiquetados `anonymous`. Los procesos no están expuestos porque contienen palabras clave restringidas.
Esta función está disponible a partir de las siguientes versiones de Aurora PostgreSQL:
+ Versión 15.3 y versiones posteriores a la 15
+ Versión 14.8 y versiones posteriores a la 14
+ Versión 13.11 y versiones posteriores a la 13
+ Versión 12.15 y versiones posteriores a la 12
+ Versión 11.20 y versiones posteriores a la 11
## Ejemplos
En el ejemplo siguiente se muestran los resultados de llamar a la función `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)
```
Algunas palabras clave restringidas se ocultarán y el resultado tendrá el siguiente aspecto:
```
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
Esta función muestra las estadísticas de la caché por niveles.
## Sintaxis
```
aurora_stat_optimized_reads_cache()
```
## Argumentos
Ninguno
## Tipo de retorno
Registro SETOF con las siguientes columnas:
+ `total_size`: tamaño total de la caché de lecturas optimizadas.
+ `used_size`: tamaño de página utilizado en la caché de lecturas optimizadas.
## Notas de uso
Esta función está disponible en las siguientes versiones de Aurora PostgreSQL:
+ Versión 15.4 y versiones posteriores a la 15
+ Versión 14.9 y versiones posteriores a la 14
## Ejemplos
A continuación se muestra la salida en una instancia 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
Devuelve una fila por cada plan de ejecución rastreado.
## Sintaxis
```
aurora_stat_plans(
showtext
)
```
## Argumentos
+ showtext: muestra el texto de la consulta y del plan. Los valores válidos son NULL, true y false. True mostrará el texto de la consulta y del plan.
## Tipo de retorno
Devuelve una fila para cada plan rastreado que contiene todas las columnas de `aurora_stat_statements` y las siguientes columnas adicionales.
+ planid: identificador del plan
+ explain\$1plan: explica el texto del plan
+ plan\$1type:
+ `no plan` - no se capturó ningún plan
+ `estimate` - plan capturado con costos estimados
+ `actual` - plan capturado con EXPLAIN ANALYZE
+ plan\$1captured\$1time: última vez que se capturó un plan
## Notas de uso
`aurora_compute_plan_id` debe estar activado y `pg_stat_statements` debe ser `shared_preload_libraries` para que se realice un seguimiento de los planes.
El número de planes disponibles se controla mediante el valor establecido en el parámetro `pg_stat_statements.max`. Cuando `aurora_compute_plan_id` está habilitado, puede realizar un seguimiento de los planes hasta el valor especificado en `aurora_stat_plans`.
Esta función está disponible desde Aurora PostgreSQL versiones 14.10, 15.5, y para todas las demás versiones posteriores.
## Ejemplos
En el ejemplo siguiente, se capturan los dos planes que corresponden al identificador de consulta -5471422286312252535 y el planid rastrea las estadísticas de los estados.
```
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
Restablece el contador de la memoria caché de wal lógica.
## Sintaxis
Para restablecer una ranura específica
```
SELECT * FROM aurora_stat_reset_wal_cache('slot_name')
```
Para restablecer todas las ranuras
```
SELECT * FROM aurora_stat_reset_wal_cache(NULL)
```
## Argumentos
`NULL` o `slot_name`
## Tipo de retorno
Mensaje de estado, cadena de texto
+ Restablece el contador de la memoria caché de wal lógica: mensaje de éxito. Este texto se devuelve cuando la función se ejecuta correctamente.
+ No se encontró la ranura de replicación. Inténtelo de nuevo. - Mensaje de error Este texto se devuelve cuando la función no se ejecuta correctamente.
## Notas de uso
Esta función está disponible para las siguientes versiones:
+ Aurora PostgreSQL 14.5 y versiones posteriores
+ Aurora PostgreSQL versión 13.8 y posteriores
+ Aurora PostgreSQL versión 12.12 y posteriores
+ Aurora PostgreSQL versión 11.7 y posteriores
## Ejemplos
En el siguiente ejemplo, se utiliza la función `aurora_stat_reset_wal_cache` para restablecer una ranura denominada `test_results` y, a continuación, se intenta restablecer una ranura que no existe.
```
=> 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
Informa del uso de los recursos en tiempo real, que consiste en las métricas de los recursos de backend y el uso de CPU para todos los procesos de backend de Aurora PostgreSQL.
## Sintaxis
```
aurora_stat_resource_usage()
```
## Argumentos
Ninguno
## Tipo de devolución
Registro SETOF con columnas:
+ pid: identificador de procesos
+ allocated\$1memory: memoria total asignada por proceso en bytes
+ used\$1memory: memoria realmente utilizada por el proceso en bytes
+ cpu\$1usage\$1percent: porcentaje de uso de CPU del proceso
## Notas de uso
Esta función muestra el uso de recursos de backend para cada proceso de backend de Aurora PostgreSQL.
Esta función está disponible a partir de las siguientes versiones de Aurora PostgreSQL:
+ Aurora PostgreSQL 17.5 y versiones posteriores a la 17
+ Aurora PostgreSQL 16.9 y versiones posteriores a la 16
+ Aurora PostgreSQL 15.13 y versiones posteriores a la 15
+ Aurora PostgreSQL 14.18 y versiones posteriores a la 14
+ Aurora PostgreSQL 13.21 y versiones posteriores a la 13
## Ejemplos
En el siguiente ejemplo se muestra el resultado de la función `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
Muestra todas las columnas `pg_stat_statements` y añade más columnas al final.
## Sintaxis
```
aurora_stat_statements(showtext boolean)
```
## Argumentos
*showtext boolean*
## Tipo de retorno
Registro SETOF con todas las columnas `pg_stat_statements` y las siguientes columnas adicionales. Para obtener más información sobre las columnas `pg_stat_statements`, consulte [https://www.postgresql.org/docs/current/pgstatstatements.html](https://www.postgresql.org/docs/current/pgstatstatements.html).
Puede restablecer las estadísticas de esta función utilizando `pg_stat_statements_reset()`.
+ `storage_blks_read`: número total de bloques compartidos leídos desde el almacenamiento de Aurora por esta instrucción.
+ `orcache_blks_hit`: número total de visitas a la caché de lecturas optimizadas por esta instrucción.
+ `storage_blk_read_time`: si se habilita `track_io_timing`, rastrea el tiempo total que la instrucción ha dedicado a leer bloques compartidos desde el almacenamiento de Aurora (en milisegundos); de lo contrario, el valor es cero. Para obtener más información, consulte [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
+ `local_blk_read_time`: si se habilita `track_io_timing`, rastrea el tiempo total que la instrucción ha dedicado a leer bloques locales (en milisegundos); de lo contrario, el valor es cero. Para obtener más información, consulte [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
+ `orcache_blk_read_time`: si se habilita `track_io_timing`, rastrea el tiempo total que la instrucción ha dedicado a leer bloques compartidos desde la caché de lecturas optimizadas (en milisegundos); de lo contrario, el valor es cero. Para obtener más información, consulte [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
+ `total_plan_peakmem`: suma total de los valores máximos de memoria durante la fase de planificación para todas las llamadas a esta instrucción. Para ver el promedio de picos de memoria durante la planificación de la instrucción, divida este valor por el número de llamadas.
+ `min_plan_peakmem`: el valor máximo de memoria más bajo registrado durante la planificación en todas las llamadas incluidas en esta instrucción.
+ `max_plan_peakmem`: el valor máximo de memoria más alto registrado durante la planificación en todas las llamadas a esta instrucción.
+ `total_exec_peakmem`: suma total de los valores máximos de memoria durante la fase de ejecución para todas las llamadas a esta instrucción. Para ver el promedio de picos de memoria durante la ejecución de la instrucción, divida este valor por el número de llamadas.
+ `min_exec_peakmem`: el valor máximo de memoria más bajo, en bytes, visto durante la ejecución en todas las llamadas a esta instrucción.
+ `max_exec_peakmem`: el valor máximo de memoria más alto, en bytes, visto durante la ejecución en todas las llamadas a esta instrucción.
**nota**
`total_plan_peakmen`, `min_plan_peakmem` y `max_plan_peakmem` solo se supervisan cuando `pg_stat_statements.track_planning` está activado.
## Notas de uso
Para utilizar la función aurora\$1stat\$1statements(), debe incluir la extensión `pg_stat_statements` en el parámetro `shared_preload_libraries`.
Esta función está disponible en las siguientes versiones de Aurora PostgreSQL:
+ Versión 15.4 y versiones posteriores a la 15
+ Versión 14.9 y versiones posteriores a la 14
Las columnas que muestran los picos de memoria están disponibles a partir de las siguientes versiones:
+ Versión 16.3 y posteriores
+ Versión 15.7 y posteriores
+ Versión 14.12 y posteriores
## Ejemplos
El siguiente ejemplo muestra cómo incluye todas las columnas pg\$1stat\$1statements y añade 11 columnas nuevas al final:
```
=> 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
Informa la información de eventos de espera para la instancia de base de datos de Aurora PostgreSQL.
## Sintaxis
```
aurora_stat_system_waits()
```
## Argumentos
Ninguno
## Tipo de retorno
Registro SETOF
## Notas de uso
Esta función devuelve el número acumulativo de esperas y el tiempo de espera acumulativo para cada evento de espera generado por la instancia de base de datos a la que está conectado actualmente.
El conjunto de registros devuelto incluye los siguientes campos:
+ `type_id` – El ID del tipo de evento de espera.
+ `event_id` – El ID del evento de espera.
+ `waits` – El número de veces que se ha producido el evento de espera.
+ `wait_time` – La cantidad total de tiempo en microsegundos transcurrido esperando este evento.
Las estadísticas devueltas por esta función se restablecen cuando se reinicia una instancia de base de datos.
## Ejemplos
En el ejemplo siguiente se muestran los resultados de llamar a la función `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
```
En el siguiente ejemplo se muestra cómo se puede usar esta función junto con `aurora_stat_wait_event` y `aurora_stat_wait_type` para producir resultados más legibles.
```
=> 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
Enumera todos los eventos de espera admitidos para Aurora PostgreSQL. Para obtener información acerca de los eventos de espera de Aurora PostgreSQL, consulte [Eventos de espera de Amazon Aurora PostgreSQL](AuroraPostgreSQL.Reference.Waitevents.md).
## Sintaxis
```
aurora_stat_wait_event()
```
## Argumentos
Ninguno
## Tipo de retorno
Registro SETOF con las siguientes columnas:
+ type\$1id: ID del tipo de evento de espera
+ event\$1id: ID del evento de espera
+ type\$1name: nombre de tipo de espera
+ event\$1name: nombre de evento de espera
## Notas de uso
Para ver nombres de eventos con tipos de eventos en lugar de los ID, utilice esta función junto con otras funciones como `aurora_stat_wait_type` y `aurora_stat_system_waits`. Los nombres de los eventos de espera devueltos por esta función son los mismos que los devueltos por la función `aurora_wait_report`.
## Ejemplos
En el ejemplo siguiente se muestran los resultados de llamar a la función `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
```
En el siguiente ejemplo se une `aurora_stat_wait_type` y `aurora_stat_wait_event` para devolver nombres de tipo y nombres de eventos para mejorar la legibilidad.
```
=> 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
Muestra todos los tipos de espera admitidos para Aurora PostgreSQL.
## Sintaxis
```
aurora_stat_wait_type()
```
## Argumentos
Ninguno
## Tipo de retorno
Registro SETOF con las siguientes columnas:
+ type\$1id: ID del tipo de evento de espera
+ type\$1name: nombre de tipo de espera
## Notas de uso
Para ver nombres de eventos de espera con tipos de eventos de espera en lugar de los ID, utilice esta función junto con otras funciones como `aurora_stat_wait_event` y `aurora_stat_system_waits`. Los nombres de tipo de espera devueltos por esta función son los mismos que los devueltos por la función `aurora_wait_report`.
## Ejemplos
En el ejemplo siguiente se muestran los resultados de llamar a la función `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
Devuelve el valor de cadena del número de versión de la edición compatible con Amazon Aurora PostgreSQL.
## Sintaxis
```
aurora_version()
```
## Argumentos
Ninguno
## Tipo de retorno
Cadena CHAR o VARCHAR
## Notas de uso
Esta función muestra la versión del motor de base de datos de la edición compatible con Amazon Aurora PostgreSQL. El número de versión se devuelve como una cadena con el formato *major*.*minor*.*patch*. Para obtener más información acerca de los números de versión de Aurora PostgreSQL, consulte [Número de versión de Aurora](AuroraPostgreSQL.Updates.md#AuroraPostgreSQL.Updates.Versions.AuroraNumber).
Puede elegir cuándo aplicar actualizaciones de versiones secundarias configurando el período de mantenimiento para el clúster de base de datos de Aurora PostgreSQL. Para aprender a hacerlo, consulte [Mantenimiento de un clúster de base de datos de Amazon Aurora](USER_UpgradeDBInstance.Maintenance.md).
A partir del lanzamiento de las versiones 13.3, 12.8, 11.13 y 10.18 de Aurora PostgreSQL, y para todas las demás versiones posteriores, los números de versión de Aurora se ajustan a los números de versión de PostgreSQL. Para obtener más información acerca de todas las versiones de Aurora PostgreSQL, consulte el tema sobre [actualizaciones de Amazon Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Updates.html) en las *notas de la versión de Aurora PostgreSQL*.
## Ejemplos
En el siguiente ejemplo se muestran los resultados de la llamada a la función `aurora_version` en un clúster de base de datos de Aurora PostgreSQL que ejecuta la [versión 12.7 de PostgreSQL, 4.2 de Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Updates.html#AuroraPostgreSQL.Updates.20180305.42) y, a continuación, la misma función en un clúster que ejecuta la [versión 13.3 de Aurora PostgreSQL](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
```
En este ejemplo se muestra cómo utilizar la función con varias opciones para obtener más detalles sobre la versión de Aurora PostgreSQL. En este ejemplo se incluye un número de versión de Aurora distinto del número de versión 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)
```
En el siguiente ejemplo se utiliza la función con las mismas opciones del ejemplo anterior. En este ejemplo se incluye un número de versión de Aurora distinto del número de versión de 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
Devuelve el número de secuencia de registro (LSN, por sus siglas en inglés) utilizado para identificar el principio de un registro en la transmisión lógica de registro anticipado (WAL, por sus siglas en inglés) del volumen del clúster de Aurora.
## Sintaxis
```
aurora_volume_logical_start_lsn()
```
## Argumentos
Ninguno
## Tipo de retorno
`pg_lsn`
## Notas de uso
Esta función identifica el principio del registro en el flujo WAL lógico para un volumen de clúster de Aurora determinado. Puede utilizar esta función al realizar una actualización de la versión principal mediante la replicación lógica y la clonación rápida de Aurora para determinar el LSN en el que se toma una instantánea o un clon de una base de datos. A continuación, puede utilizar la replicación lógica para transmitir de forma continua los datos más recientes registrados después del LSN y sincronizar los cambios del publicador al suscriptor.
Para obtener más información sobre el uso de la replicación lógica para una actualización de versión principal, consulte [Uso de la replicación lógica para realizar una actualización de la versión principal para Aurora PostgreSQL](AuroraPostgreSQL.MajorVersionUpgrade.md).
Esta función está disponible para las siguientes versiones de Aurora PostgreSQL:
+ Versión 15.2 y versiones posteriores a la 15
+ Versión 14.3 y versiones posteriores a la 14
+ Versión 13.6 y versiones posteriores a la 13
+ Versión 12.10 y versiones posteriores a la 12
+ Versión 11.15 y versiones posteriores a la 11
+ Versión 10.20 y versiones posteriores a la 10
## Ejemplos
Puede obtener el número de secuencia de registro (LSN) mediante la siguiente consulta:
```
postgres=> SELECT aurora_volume_logical_start_lsn();
aurora_volume_logical_start_lsn
---------------
0/402E2F0
(1 row)
```
# aurora\$1wait\$1report
Esta función muestra la actividad del evento de espera durante un período de tiempo.
## Sintaxis
```
aurora_wait_report([time])
```
## Argumentos
*time (opcional) *
Tiempo en segundos. El valor predeterminado es de 10 segundos.
## Tipo de retorno
Registro SETOF con las siguientes columnas:
+ type\$1name: nombre de tipo de espera
+ event\$1name: nombre de evento de espera
+ wait: número de esperas
+ wait\$1time: tiempo de espera en milisegundos
+ ms\$1per\$1wait: promedio de milisegundos por el número de una espera
+ waits\$1per\$1xact: promedio de esperas por el número de una transacción
+ ms\$1per\$1wait: promedio de milisegundos por el número de transacciones
## Notas de uso
Esta función está disponible a partir de la versión 1.1 de Aurora PostgreSQL compatible con PostgreSQL 9.6.6 y versiones superiores.
Para utilizar esta función, primero debe crear la extensión `aurora_stat_utils` de Aurora PostgreSQL, según se indica:
```
=> CREATE extension aurora_stat_utils;
CREATE EXTENSION
```
Para obtener más información acerca de las versiones disponibles de la extensión de Aurora PostgreSQL, consulte el tema sobre [versiones de extensiones para Amazon Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Extensions.html) en las *Notas de la versión de Aurora PostgreSQL*.
Esta función calcula los eventos de espera en el nivel de instancia comparando dos instantáneas de datos estadísticos de la función aurora\$1stat\$1system\$1waits() y las vistas de estadísticas de PostgreSQL pg\$1stat\$1database.
Para obtener más información sobre `aurora_stat_system_waits()` y `pg_stat_database`, consulte el tema sobre el [recopilador de estadísticas](https://www.postgresql.org/docs/current/monitoring-stats.html#PG-STAT-DATABASE-VIEW) en la *documentación de PostgreSQL*.
Cuando se ejecuta, esta función toma una instantánea inicial, espera el número de segundos especificado y, a continuación, toma una segunda instantánea. La función compara las dos instantáneas y devuelve la diferencia. Esta diferencia representa la actividad de la instancia durante ese intervalo de tiempo.
En la instancia de escritor, la función también muestra el número de transacciones confirmadas y TPS (transacciones por segundo). Esta función devuelve información en el nivel de instancia e incluye todas las bases de datos de la instancia.
## Ejemplos
En este ejemplo se muestra cómo crear la extensión aurora\$1stat\$1utils para poder utilizar la función aurora\$1wait\$1report.
```
=> CREATE extension aurora_stat_utils;
CREATE EXTENSION
```
En este ejemplo se muestra cómo comprobar el informe de espera durante 10 segundos.
```
=> 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
```
En este ejemplo se muestra cómo comprobar el informe de espera durante 60 segundos.
```
=> 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
```
# Parámetros de Amazon Aurora PostgreSQL.
El clúster de base de datos de Amazon Aurora se administra de la misma manera que las instancias de base de datos de Amazon RDS, mediante el uso de parámetros en un grupo de parámetros de base de datos. Sin embargo, Amazon Aurora se diferencia de Amazon RDS en que un clúster de base de datos de Aurora tiene varias instancias de base de datos. Algunos de los parámetros que se usan para administrar el clúster de base de datos de Amazon Aurora se aplican a todo el clúster, mientras que otros parámetros se aplican solo a una instancia de base de datos determinada en el clúster de base de datos, como se indica a continuación:
+ **Grupo de parámetros del clúster de base de datos**: un grupo de parámetros del clúster de base de datos contiene el conjunto de parámetros de configuración del motor que se aplican en todo el clúster de base de datos de Aurora. Por ejemplo, la administración de la caché del clúster es una característica de un clúster de base de datos de Aurora que se controla mediante el parámetro `apg_ccm_enabled`, que forma parte del grupo de parámetros del clúster de base de datos. El grupo de parámetros del clúster de base de datos también contiene la configuración predeterminada del grupo de parámetros de base de datos para las instancias de base de datos que componen el clúster.
+ **Grupo de parámetros de base de datos**: un grupo de parámetros de base de datos es el conjunto de valores de configuración del motor que se aplican a una instancia de base de datos específica de ese tipo de motor. Los grupos de parámetros de base de datos del motor de base de datos de PostgreSQL se usan en una instancia de base de datos de RDS para PostgreSQL y en el clúster de base de datos de Aurora PostgreSQL. Estos ajustes de configuración se aplican a propiedades que pueden variar entre las instancias de base de datos dentro de un clúster de Aurora, como los tamaños de los búferes de memoria.
El usuario administra los parámetros de nivel de clúster de los grupos de parámetros de clúster de base de datos. El usuario administra los parámetros de nivel de instancia de los grupos de parámetros de base de datos. Puede administrar los parámetros con la consola de Amazon RDS, la AWS CLI o la API de Amazon RDS. Hay comandos independientes para administrar los parámetros de nivel de clúster y los parámetros de nivel de instancia.
+ Para administrar parámetros de nivel de clúster en un grupo de parámetros en un clúster de base de datos, utilice el comando [modify-db-cluster-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster-parameter-group.html) de la AWS CLI.
+ Para administrar parámetros de nivel de instancia en un grupo de parámetros de base de datos para una instancia de base de datos del clúster de base de datos, utilice el comando [modify-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-parameter-group.html) de la AWS CLI.
Para obtener más información sobre la AWS CLI, consulte la sección [Uso de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-using.html) en la *Guía del usuario de la AWS Command Line Interface*.
Para obtener más información acerca de los grupos de parámetros, consulte [Grupos de parámetros para Amazon Aurora](USER_WorkingWithParamGroups.md).
## Visualización de los parámetros del clúster y de la base de datos de Aurora PostgreSQL
Puede ver todos los grupos de parámetros predeterminados disponibles para las instancias de RDS para instancias de base de datos de PostgreSQL y para los clústeres de base de datos de Aurora PostgreSQL en la Consola de administración de AWS. Los grupos de parámetros predeterminados para todos los motores de base de datos y tipos y versiones de clústeres de base de datos se enumeran para cada región de AWS. También se enumeran los grupos de parámetros personalizados.
En lugar de verlo en la Consola de administración de AWS, también puede enumerar los parámetros contenidos en los grupos de parámetros de clústeres de bases de datos y grupos de parámetros de bases de datos utilizando la AWS CLI o la API de Amazon RDS. Por ejemplo, para enumerar los parámetros de un grupo de parámetros de un clúster de base de datos, utilice el comando de la AWS CLI [describe-db-cluster-parameters](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-cluster-parameters.html) como se indica a continuación:
```
aws rds describe-db-cluster-parameters --db-cluster-parameter-group-name default.aurora-postgresql12
```
El comando muestra descripciones JSON detalladas de cada parámetro. Para reducir la cantidad de información devuelta, puede especificar lo que desea con la opción `--query`. Por ejemplo, puede obtener el nombre del parámetro, su descripción y los valores permitidos del grupo de parámetros del clúster de base de datos de Aurora PostgreSQL 12 predeterminado de la siguiente manera:
Para Linux, macOS o 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}]'
```
Para 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 grupo de parámetros de un clúster de base de datos de Aurora incluye el grupo de parámetros de instancia de base de datos y los valores predeterminados de un motor de base de datos de Aurora determinado. Puede obtener la lista de parámetros de base de datos del mismo grupo de parámetros predeterminados de Aurora PostgreSQL con el comando AWS CLI [describe-db-parameters](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-parameters.html) como se muestra a continuación.
Para Linux, macOS o Unix:
```
aws rds describe-db-parameters --db-parameter-group-name default.aurora-postgresql12 \
--query 'Parameters[].[{ParameterName:ParameterName,Description:Description,ApplyType:ApplyType,AllowedValues:AllowedValues}]'
```
Para Windows:
```
aws rds describe-db-parameters --db-parameter-group-name default.aurora-postgresql12 ^
--query "Parameters[].[{ParameterName:ParameterName,Description:Description,ApplyType:ApplyType,AllowedValues:AllowedValues}]"
```
Los comandos anteriores muestran listas de parámetros del grupo de parámetros de base de datos o del clúster de base de datos con descripciones y otros detalles especificados en la consulta. A continuación, se muestra un ejemplo de respuesta.
```
[
[
{
"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"
}
],...
```
A continuación se muestran las tablas que contienen los valores del parámetro del clúster de base de datos y del parámetro de la base de datos predeterminados de la versión 14 de Aurora PostgreSQL.
## Parámetros de nivel de clúster de Aurora PostgreSQL
Puede ver los parámetros de nivel de clúster disponibles para una versión de Aurora PostgreSQL específica usando la consola de administración de AWS, la CLI de AWS o la API de Amazon RDS. Para obtener información sobre cómo ver los parámetros en grupos de parámetros del clúster de base de datos de Aurora PostgreSQL en la consola de RDS, consulte [Visualización de los valores de parámetros de un grupo de parámetros de clúster de base de datos en Amazon Aurora](USER_WorkingWithParamGroups.ViewingCluster.md).
Algunos parámetros en el nivel de clúster no están disponibles en todas las versiones y otros están en desuso. Para obtener información sobre cómo ver los parámetros de una versión específica de Aurora PostgreSQL, consulte [Visualización de los parámetros del clúster y de la base de datos de Aurora PostgreSQL](#AuroraPostgreSQL.Reference.ParameterGroups-viewing-parameters).
Por ejemplo, la siguiente tabla muestra los parámetros disponibles en el grupo de parámetros del clúster de base de datos predeterminado de la versión 14 de Aurora PostgreSQL. Si crea un clúster de base de datos de Aurora PostgreSQL sin especificar su propio grupo de parámetros de base de datos personalizado, el clúster de base de datos se crea con el grupo de parámetros de clúster de base de datos de Aurora predeterminado de la versión elegida, como `default.aurora-postgresql14`, `default.aurora-postgresql13`, etc.
Para obtener una lista de los parámetros de instancia de base de datos del mismo grupo de parámetros de base de datos predeterminado, consulte [Parámetros de nivel de instancia de Aurora PostgreSQL](#AuroraPostgreSQL.Reference.Parameters.Instance).
| Nombre del parámetro | Descripción | Valor predeterminado |
| --- | --- | --- |
| ansi\$1constraint\$1trigger\$1ordering | Cambia el orden de disparo de los desencadenadores de restricciones para que sean compatibles con el estándar ANSI SQL. | – |
| ansi\$1force\$1foreign\$1key\$1checks | Garantiza que se produzcan siempre acciones referenciales, como la eliminación en cascada o la actualización en cascada, independientemente de los distintos contextos de desencadenamiento que existan para la acción. | – |
| ansi\$1qualified\$1update\$1set\$1target | Admite los calificadores de tabla y de esquema en las instrucciones UPDATE… Instrucciones SET. | – |
| apg\$1ccm\$1enabled | Habilita o desactiva la administración de la caché del clúster. | – |
| apg\$1enable\$1batch\$1mode\$1function\$1execution | Habilita las funciones en modo lote para procesar conjuntos de filas a la vez. | – |
| apg\$1enable\$1correlated\$1any\$1transform | Permite que el planificador transforme la subconsulta ANY correlacionada (IN/NOT IN) en JOIN cuando sea posible. | – |
| apg\$1enable\$1function\$1migration | Permite al planificador migrar las funciones escalares elegibles a la cláusula FROM. | – |
| apg\$1enable\$1not\$1in\$1transform | Permite al planificador transformar la subconsulta NOT IN en ANTI JOIN cuando sea posible. | – |
| apg\$1enable\$1remove\$1redundant\$1inner\$1joins | Permite al planificador eliminar las uniones internas redundantes. | – |
| apg\$1enable\$1semijoin\$1push\$1down | Permite el uso de filtros semijoin para las uniones hash. | – |
| apg\$1plan\$1mgmt.capture\$1plan\$1baselines | Modo de línea base del plan de captura. manual - habilitar la captura del plan para cualquier sentencia SQL, desactivado - deshabilitar la captura del plan, automático - habilitar la captura del plan para las instrucciones en pg\$1stat\$1statements que cumplen los criterios de elegibilidad. | apagar |
| apg\$1plan\$1mgmt.max\$1databases | Establece el número máximo de bases de datos que se pueden administrar con apg\$1plan\$1mgmt. | 10 |
| apg\$1plan\$1mgmt.max\$1plans | Establece el número máximo de planes que se pueden almacenar en caché mediante apg\$1plan\$1mgmt. | 10000 |
| apg\$1plan\$1mgmt.plan\$1retention\$1period | Número máximo de días desde que un plan se usó por última vez antes de que un plan se elimine automáticamente. | 32 |
| apg\$1plan\$1mgmt.unapproved\$1plan\$1execution\$1threshold | Costo total estimado del plan por debajo del cual se ejecutará un plan no aprobado. | 0 |
| apg\$1plan\$1mgmt.use\$1plan\$1baselines | Use solo planes aprobados o fijos para las instrucciones administradas. | false |
| application\$1name | Define el nombre de la aplicación sobre la que informarán las estadísticas y los registros. | – |
| array\$1nulls | Permite la entrada de elementos NULL en matrices. | – |
| aurora\$1compute\$1plan\$1id | Supervisa los planes de ejecución de consultas para detectar los planes de ejecución que contribuyen a la carga actual de la base de datos y para hacer un seguimiento de las estadísticas de rendimiento de los planes de ejecución a lo largo del tiempo. Para obtener más información, consulte [Monitorización de planes de ejecución de consultas para Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraPostgreSQL.Monitoring.Query.Plans.html). | on |
| authentication\$1timeout | Establece el tiempo máximo permitido para completar una autenticación del cliente. | – |
| auto\$1explain.log\$1analyze | Usa EXPLAIN ANALYZE para el registro de planes. | – |
| auto\$1explain.log\$1buffers | Usa los búferes de registro. | – |
| auto\$1explain.log\$1format | Usa el formato EXPLAIN para el registro del plan. | – |
| auto\$1explain.log\$1min\$1duration | Establece el tiempo mínimo de ejecución por encima del cual se registrarán los planes. | – |
| auto\$1explain.log\$1nested\$1statements | Registra las instrucciones anidadas. | – |
| auto\$1explain.log\$1timing | Recopila datos de cronometraje, no solo recuentos de filas. | – |
| auto\$1explain.log\$1triggers | Incluye estadísticas de desencadenado en los planes. | – |
| auto\$1explain.log\$1verbose | Usa EXPLAIN VERBOSE para el registro de planes. | – |
| auto\$1explain.sample\$1rate | Permite procesar una fracción de las consultas. | – |
| autovacuum | Inicia el subproceso de autovacuum. | – |
| autovacuum\$1analyze\$1scale\$1factor | Número de inserciones de tuplas, actualizaciones o borrados antes del análisis como fracción de retuplas. | 0,05 |
| autovacuum\$1analyze\$1threshold | Número mínimo de inserciones, actualizaciones o eliminaciones de tuplas antes del análisis. | – |
| autovacuum\$1freeze\$1max\$1age | Antigüedad con la que se debe aplicar autovacuum a una tabla para impedir el reinicio de los ID. | – |
| autovacuum\$1max\$1workers | Define el número máximo de procesos de empleados de autovacuum que se ejecutan simultáneamente. | GREATEST(DBInstanceClassMemory/64371566592,3) |
| autovacuum\$1multixact\$1freeze\$1max\$1age | Antigüedad de multiexact con la que se autovacía una tabla para evitar el reinicio de multiexact. | – |
| autovacuum\$1naptime | (s) Tiempo de espera entre ejecuciones de autovacuum. | 5 |
| autovacuum\$1vacuum\$1cost\$1delay | (ms) Retardo del costo del vacío en milisegundos, para autovacuum. | 5 |
| autovacuum\$1vacuum\$1cost\$1limit | Importe del costo del vacío disponible antes del periodo de reposo para autovacuum. | GREATEST(log(DBInstanceClassMemory/21474836480)\$1600,200) |
| autovacuum\$1vacuum\$1insert\$1scale\$1factor | Número de inserciones de tuplas antes del vacío como fracción de retuplas. | – |
| autovacuum\$1vacuum\$1insert\$1threshold | Número mínimo de inserciones de tuplas antes de vacuum o -1 para desactivar los vacíos de inserción. | – |
| autovacuum\$1vacuum\$1scale\$1factor | Número de actualizaciones o borrados de tuplas antes del vacío como fracción de reltuples. | 0.1 |
| autovacuum\$1vacuum\$1threshold | Número mínimo de actualizaciones o borrados de tuplas antes del vacío. | – |
| autovacuum\$1work\$1mem | (kB) Establece la memoria máxima que puede utilizar cada proceso de empleado de autovacuum. | GREATEST(DBInstanceClassMemory/32768,131072) |
| babelfishpg\$1tds.default\$1server\$1name | Nombre predeterminado del servidor de Babelfish | Microsoft SQL Server |
| babelfishpg\$1tds.listen\$1addresses | Establece el nombre de host o las direcciones IP para escuchar el TDS. | \$1 |
| babelfishpg\$1tds.port | Establece el puerto TCP de TDS en el que escucha el servidor. | 1433 |
| babelfishpg\$1tds.tds\$1debug\$1log\$1level | Establece el nivel de registro en TDS, 0 desactiva el registro | 1 |
| babelfishpg\$1tds.tds\$1default\$1numeric\$1precision | Establece la precisión predeterminada del tipo numérico que se enviará en los metadatos de la columna TDS si el motor no especifica ninguna. | 38 |
| babelfishpg\$1tds.tds\$1default\$1numeric\$1scale | Establece la escala predeterminada del tipo numérico que se enviará en los metadatos de la columna TDS si el motor no especifica una. | 8 |
| babelfishpg\$1tds.tds\$1default\$1packet\$1size | Establece el tamaño de paquete predeterminado para todos los clientes de SQL Server que se conectan. | 4096 |
| babelfishpg\$1tds.tds\$1default\$1protocol\$1version | Establece la versión del protocolo TDS predeterminada para todos los clientes que se conectan | DEFAULT |
| babelfishpg\$1tds.tds\$1ssl\$1encrypt | Establece la opción de cifrado SSL | 0 |
| babelfishpg\$1tds.tds\$1ssl\$1max\$1protocol\$1version | Establece la versión máxima del protocolo SSL/TLS a usar para la sesión tds | TLSv1.2 |
| babelfishpg\$1tds.tds\$1ssl\$1min\$1protocol\$1version | Establece la versión mínima del protocolo SSL/TLS que se puede usar para la sesión TDS. | TLSv1.2 de Aurora PostgreSQL versión 16, TLSv1 para versiones anteriores a Aurora PostgreSQL versión 16 |
| babelfishpg\$1tsql.default\$1locale | Configuración regional predeterminada que se usará para las colaciones creadas por CREATE COLLATION. | en-US |
| babelfishpg\$1tsql.migration\$1mode | Define si se admiten múltiples bases de datos de usuarios | Varias bases de datos de Aurora PostgreSQL versión 16, una sola base de datos para versiones anteriores a Aurora PostgreSQL versión 16 |
| babelfishpg\$1tsql.server\$1collation\$1name | Nombre de la intercalación de servidores predeterminada | sql\$1latin1\$1general\$1cp1\$1ci\$1as |
| babelfishpg\$1tsql.version | Establece la salida de la variable @@VERSION | predeterminado |
| backend\$1flush\$1after | (8Kb) Número de páginas después de las cuales las escrituras realizadas anteriormente se vacían al disco. | – |
| backslash\$1quote | Establece si se permite el uso de \$1\$1 en cadenas literales. | – |
| backtrace\$1functions | Backtrace de registro de errores en estas funciones. | – |
| bytea\$1output | Establece el formato de salida para bytea. | – |
| check\$1function\$1bodies | Comprueba los cuerpos de las funciones durante la ejecución de CREATE FUNCTION. | – |
| client\$1connection\$1check\$1interval | Establece el intervalo de tiempo entre las comprobaciones de desconexión mientras se ejecutan las consultas. | – |
| client\$1encoding | Define la codificación del conjunto de caracteres del cliente. | UTF8 |
| client\$1min\$1messages | Establece los niveles de mensajes que se envían al cliente. | – |
| compute\$1query\$1id | Computa los identificadores de consultas. | auto |
| config\$1file | Establece el archivo de configuración principal del servidor. | /rdsdbdata/config/postgresql.conf |
| constraint\$1exclusion | Habilita el planificador para que use restricciones con el fin de optimizar las consultas. | – |
| cpu\$1index\$1tuple\$1cost | Establece la estimación del planificador del costo de procesar cada entrada de índice durante un examen del índice. | – |
| cpu\$1operator\$1cost | Establece la estimación del planificador del costo de procesar cada operador o llamada a una función. | – |
| cpu\$1tuple\$1cost | Establece la estimación del planificador del costo de procesar cada tupla (fila). | – |
| cron.database\$1name | Establece la base de datos para almacenar las tablas de metadatos de pg\$1cron | postgres |
| cron.log\$1run | Registra todas las ejecuciones de trabajos en la tabla job\$1run\$1details | on |
| cron.log\$1statement | Registra todas las instrucciones cron antes de la ejecución. | apagar |
| cron.max\$1running\$1jobs | Número máximo de trabajos que pueden ejecutarse simultáneamente. | 5 |
| cron.use\$1background\$1workers | Habilita empleados en segundo plano para pg\$1cron | on |
| cursor\$1tuple\$1fraction | Establece la estimación de los planificadores de la fracción de filas de un cursor que se recuperará. | – |
| data\$1directory | Establece el directorio de datos del servidor. | /rdsdbdata/db |
| datestyle | Define el formato de visualización para los valores de fecha y hora. | – |
| db\$1user\$1namespace | Habilita los nombres de usuario por base de datos. | – |
| deadlock\$1timeout | (ms) Establece el tiempo de espera de un bloqueo antes de comprobar si hay un bloqueo. | – |
| debug\$1pretty\$1print | Aplica una sangría a las visualizaciones del árbol de análisis y de planificación. | – |
| debug\$1print\$1parse | Registra el árbol de análisis de cada consulta. | – |
| debug\$1print\$1plan | Registra el plan de ejecución de cada consulta. | – |
| debug\$1print\$1rewritten | Registra el árbol de análisis reescrito de cada consulta. | – |
| default\$1statistics\$1target | Define el objetivo de estadística predeterminado. | – |
| default\$1tablespace | Define el espacio de tabla predeterminado en el que se deben crear las tablas y los índices. | – |
| default\$1toast\$1compression | Establece el método de compresión predeterminado para los valores comprimibles. | – |
| default\$1transaction\$1deferrable | Define el estado diferible predeterminado de las nuevas transacciones. | – |
| default\$1transaction\$1isolation | Define el nivel de aislamiento de cada nueva transacción. | – |
| default\$1transaction\$1read\$1only | Define el estado de solo lectura predeterminado de las nuevas transacciones. | – |
| efective\$1cache\$1size | (8kB) Establece la suposición de los planificadores sobre el tamaño de la caché del disco. | SUM(DBInstanceClassMemory/12038,-50003) |
| effective\$1io\$1concurrency | Número de solicitudes simultáneas que el subsistema del disco puede gestionar de un modo eficiente. | – |
| enable\$1async\$1append | Habilita el uso de planes de append asíncronos por parte de los planificadores. | – |
| enable\$1bitmapscan | Habilita el uso de planes de examen de mapas de bits por parte de los planificadores. | – |
| enable\$1gathermerge | Habilita el uso de planes de fusión de recopilación por parte de los planificadores. | – |
| enable\$1hashagg | Habilita el uso de planes de agregación con hash por parte de los planificadores. | – |
| enable\$1hashjoin | Habilita el uso de planes de combinación con hash por parte de los planificadores. | – |
| enable\$1incremental\$1sort | Habilita el uso de pasos de ordenación incrementales por parte de los planificadores. | – |
| enable\$1indexonlyscan | Habilita el uso de planes de examen solo de índice por parte de los planificadores. | – |
| enable\$1indexscan | Habilita el uso de planes de examen de índice por parte de los planificadores. | – |
| enable\$1material | Habilita el uso de materialización por parte de los planificadores. | – |
| enable\$1memoize | Habilita el uso de memorización para los planificadores | – |
| enable\$1mergejoin | Habilita el uso de planes de combinación por fusión por parte de los planificadores. | – |
| enable\$1nestloop | Habilita el uso de planes de combinación de bucles anidados por parte de los planificadores. | – |
| enable\$1parallel\$1append | Habilita el uso de planes de append en paralelo por parte de los planificadores. | – |
| enable\$1parallel\$1hash | Habilita el uso de planes hash paralelos por parte de los planificadores. | – |
| enable\$1partition\$1pruning | Habilita la depuración de particiones en tiempo de planificación y de ejecución. | – |
| enable\$1partitionwise\$1aggregate | Habilita la agregación y agrupación de particiones. | – |
| enable\$1partitionwise\$1join | Habilita la combinación de particiones. | – |
| enable\$1seqscan | Habilita el uso de planes de examen secuencial por parte de los planificadores. | – |
| enable\$1sort | Habilita el uso de pasos de ordenación explícitos por parte de los planificadores. | – |
| enable\$1tidscan | Habilita el uso de planes de examen TID por parte de los planificadores. | – |
| escape\$1string\$1warning | Advierte sobre los escapes de barra invertida en los literales de cadena ordinarios. | – |
| exit\$1on\$1error | Termina la sesión en caso de error. | – |
| extra\$1float\$1digits | Define el número de dígitos que se muestran para los valores de punto flotante. | – |
| force\$1parallel\$1mode | Fuerza el uso de las facilidades de consulta paralela. | – |
| from\$1collapse\$1limit | Define el tamaño de la lista FROM por encima del cual las subconsultas no se contraen. | – |
| geqo | Habilita la optimización de consultas geneticas. | – |
| geqo\$1effort | GEQO: esfuerzo que se usa para definir el valor predeterminado de otros parámetros de GEQO. | – |
| geqo\$1generations | GEQO: número de iteraciones del algoritmo. | – |
| geqo\$1pool\$1size | GEQO: número de individuos de la población. | – |
| geqo\$1seed | GEQO: valor de inicialización para la selección de ruta aleatoria. | – |
| geqo\$1selection\$1bias | GEQO: presión selectiva dentro de la población. | – |
| geqo\$1threshold | Define el umbral de los elementos FROM por encima de los cuales se usa GEQO. | – |
| gin\$1fuzzy\$1search\$1limit | Define el resultado máximo permitido para la búsqueda exacta por GIN. | – |
| gin\$1pending\$1list\$1limit | (kB) Establece el tamaño máximo de la lista pendiente para el índice de GIN. | – |
| hash\$1mem\$1multiplier | Múltiplo de work\$1mem que se utilizará para las tablas hash. | – |
| hba\$1file | Establece el archivo de configuración de HBA de servidores. | /rdsdbdata/config/pg\$1hba.conf |
| hot\$1standby\$1feedback | Permite la retroalimentación de una espera activa al primario que evitará conflictos de consulta. | on |
| huge\$1pages | Reduce la sobrecarga cuando una instancia de base de datos trabaja con grandes fragmentos contiguos de memoria, como los utilizados por los búferes compartidos. Se activa de forma predeterminada para todas las clases de instancia de base de datos que no sean las siguientes: t3.medium, db.t3.large, db.t4g.medium y db.t4g.large. | on |
| ident\$1file | Establece el archivo de configuración de ident de servidores. | /rdsdbdata/config/pg\$1hba.conf |
| idle\$1in\$1transaction\$1session\$1timeout | (ms) Establece la duración máxima permitida de cualquier transacción en espera. | 86400000 |
| idle\$1session\$1timeout | Finaliza cualquier sesión que haya estado inactiva (es decir, a la espera de una consulta por parte de un cliente), pero no dentro de una transacción abierta, durante más tiempo del especificado | – |
| intervalstyle | Define el formato de visualización para los valores de intervalo. | – |
| join\$1collapse\$1limit | Define el tamaño de la lista FROM por encima del cual las construcciones JOIN no se aplanan. | – |
| krb\$1caseins\$1users | Establece si los nombres de usuario de la GSSAPI (Generic Security Service API) deben distinguir entre mayúsculas y minúsculas (verdadero) o no. De forma predeterminada, este parámetro está configurado en falso, por lo que Kerberos espera que los nombres de usuario distingan entre mayúsculas y minúsculas. Para obtener más información, consulte [GSSAPI Authentication](https://www.postgresql.org/docs/current/gssapi-auth.html) (Autenticación de GSSAPI) en la documentación de PostgreSQL. | false |
| lc\$1messages | Define el idioma en el que se muestran los mensajes. | – |
| lc\$1monetary | Define la configuración regional para el formato de las cantidades monetarias. | – |
| lc\$1numeric | Define la configuración regional para el formato de los números. | – |
| lc\$1time | Define la configuración regional para el formato de los valores de fecha y hora. | – |
| listen\$1addresses | Establece el nombre de host o las direcciones IP para escuchar. | \$1 |
| lo\$1compat\$1privileges | Habilita el modo de compatibilidad con versiones pasadas para las comprobaciones de privilegios en objetos grandes. | 0 |
| log\$1autovacuum\$1min\$1duration | (ms) Establece el tiempo mínimo de ejecución a partir del cual se registrarán las acciones de autovacuum. | 10000 |
| log\$1connections | Registra cada conexión realizada correctamente. | – |
| log\$1destination | Establece el destino de la salida del registro del servidor. | stderr |
| log\$1directory | Establece el directorio de destino para los archivos de registro. | /rdsdbdata/log/error |
| log\$1disconnections | Registra el final de una sesión, incluida su duración. | – |
| log\$1duration | Registra la duración de cada instrucción de SQL completada. | – |
| log\$1error\$1verbosity | Define el detalle de los mensajes registrados. | – |
| log\$1executor\$1stats | Escribe las estadísticas de rendimiento del ejecutor en el registro del servidor. | – |
| log\$1file\$1mode | Establece los permisos de los archivos de registro. | 0644 |
| log\$1filename | Define el patrón del nombre de archivo de los archivos de registro. | postgresql.log.%Y-%m-%d-%H%M |
| logging\$1collector | Inicia un subproceso para capturar el resultado de stderr o csvlogs en archivos de registro. | 1 |
| log\$1hostname | Registra el nombre del host en los registros de conexión. | 0 |
| logical\$1decoding\$1work\$1mem | (kB) Cada búfer de reordenamiento interno puede usar esta cantidad de memoria antes de volcar en el disco. | – |
| log\$1line\$1prefix | Controla la información prefijada en cada línea de registro. | %t: %r: %u@%d: %p]: |
| log\$1lock\$1waits | Registra las esperas de bloqueo largas. | – |
| log\$1min\$1duration\$1sample | (ms) Establece el tiempo mínimo de ejecución a partir del cual se registrará una muestra de instrucciones. El muestreo se determina mediante log\$1statement\$1sample\$1rate. | – |
| log\$1min\$1duration\$1statement | (ms) Establece el tiempo mínimo de ejecución por encima del cual se registrarán las instrucciones. | – |
| log\$1min\$1error\$1statement | Hace que se registren todas las instrucciones que generen un error por encima de este nivel. | – |
| log\$1min\$1messages | Define los niveles de los mensajes que se registran. | – |
| log\$1parameter\$1max\$1length | (B) Al registrar instrucciones limita los valores de los parámetros registrados a los primeros N bytes. | – |
| log\$1parameter\$1max\$1length\$1on\$1error | (B) Cuando se informa de un error, limita los valores de los parámetros registrados a los primeros N bytes. | – |
| log\$1parser\$1stats | Escribe las estadísticas de rendimiento del analizador en el registro del servidor. | – |
| log\$1planner\$1stats | Escribe las estadísticas de rendimiento del planificador en el registro del servidor. | – |
| log\$1replication\$1commands | Registra cada comando de replicación. | – |
| log\$1rotation\$1age | (min) La rotación automática del archivo de registro se producirá después de N minutos. | 60 |
| log\$1rotation\$1size | (kB) La rotación automática del archivo de registro se producirá después de N kilobytes. | 100000 |
| log\$1statement | Define el tipo de declaraciones que se deben registrar. | – |
| log\$1statement\$1sample\$1rate | Fracción de instrucciones que exceden la muestra de log\$1min\$1duration que se registrará. | – |
| log\$1statement\$1stats | Escribe las estadísticas de rendimiento acumulativas en el registro del servidor. | – |
| log\$1temp\$1files | (kB) Registra el uso de archivos temporales mayores a este número de kilobytes. | – |
| log\$1timezone | Establece la zona horaria que se usará en los mensajes de registro. | UTC |
| log\$1transaction\$1sample\$1rate | Establece la fracción de transacciones que se tienen que registrar para las nuevas transacciones. | – |
| log\$1truncate\$1on\$1rotation | Permite truncar los archivos de registro existentes con el mismo nombre durante la rotación del registro. | 0 |
| maintenance\$1io\$1concurrency | Una variante de effective\$1io\$1concurrency que se utiliza para trabajos de mantenimiento. | 1 |
| maintenance\$1work\$1mem | (kB) Establece la memoria máxima que se puede usar para las operaciones de mantenimiento | GREATEST(DBInstanceClassMemory/63963136\$11024,65536) |
| max\$1connections | Define el número máximo de conexiones simultáneas. | LEAST(DBInstanceClassMemory/9531392,5000) |
| max\$1files\$1per\$1process | Define el número máximo de archivos abiertos simultáneamente para cada proceso del servidor. | – |
| max\$1locks\$1per\$1transaction | Define el número máximo de bloqueos por transacción. | 64 |
| max\$1logical\$1replication\$1workers | Número máximo de procesos de empleados de replicación lógica. | – |
| max\$1parallel\$1maintenance\$1workers | Establece el número máximo de procesos en paralelo por operación de mantenimiento. | – |
| max\$1parallel\$1workers | Establece el número máximo de empleados en paralelo que pueden estar activos a la vez. | GREATEST(\$1DBInstanceVCPU/2,8) |
| max\$1parallel\$1workers\$1per\$1gather | Establece el número máximo de procesos en paralelo por nodo ejecutor. | – |
| max\$1pred\$1locks\$1per\$1page | Establece el número máximo de tuplas bloqueadas por predicado por página. | – |
| max\$1pred\$1locks\$1per\$1relation | Establece el número máximo de páginas y tuplas bloqueadas por predicado por relación. | – |
| max\$1pred\$1locks\$1per\$1transaction | Define el número máximo de bloqueos de predicado por transacción. | – |
| max\$1prepared\$1transactions | Define el número máximo de transacciones preparadas simultáneamente. | 0 |
| max\$1replication\$1slots | Establece el número máximo de ranuras de replicación que puede admitir el servidor. | 20 |
| max\$1slot\$1wal\$1keep\$1size | (MB) Las ranuras de replicación se marcarán como fallidas, y los segmentos se liberarán para su eliminación o reciclaje si esta cantidad de espacio está ocupada por la WAL en el disco. | – |
| max\$1stack\$1depth | (kB) Establece la profundidad máxima de la pila, en kilobytes. | 6144 |
| max\$1standby\$1streaming\$1delay | (ms) Establece el retardo máximo antes de cancelar las consultas cuando un servidor en espera activa está procesando datos de WAL en flujo. | 14000 |
| max\$1sync\$1workers\$1per\$1subscription | Número máximo de empleados de sincronización por suscripción | 2 |
| max\$1wal\$1senders | Establece el número máximo de procesos emisores de WAL que se ejecutan simultáneamente. | 10 |
| max\$1worker\$1processes | Establece el número máximo de procesos de empleados que se ejecutan simultáneamente. | GREATEST(\$1DBInstanceVCPU\$12,8) |
| min\$1dynamic\$1shared\$1memory | (MB) Cantidad de memoria compartida dinámica reservada al inicio. | – |
| min\$1parallel\$1index\$1scan\$1size | (8kB) Establece la cantidad mínima de datos de índice para un examen en paralelo. | – |
| min\$1parallel\$1table\$1scan\$1size | (8kB) Establece la cantidad mínima de datos de tabla para un examen en paralelo. | – |
| old\$1snapshot\$1threshold | (min) Tiempo antes de que una instantánea se vuelva demasiado antigua para leer las páginas modificadas después de la captura de la instantánea. | – |
| orafce.nls\$1date\$1format | Emula el comportamiento de salida de fecha de Oracle. | – |
| orafce.timezone | Especifica la zona horaria utilizada para la función sysdate. | – |
| parallel\$1leader\$1participation | Controla si Gather y Gather Merge también ejecutan subplanes. | – |
| parallel\$1setup\$1cost | Establece la estimación de los planificadores del costo de iniciar procesos de empleados para la consulta paralela. | – |
| parallel\$1tuple\$1cost | Establece la estimación de los planificadores del costo de pasar cada tupla (fila) del empleado al backend maestro. | – |
| password\$1encryption | Codifica las contraseñas. | – |
| pgaudit.log | Especifica qué clases de instrucciones se registrarán mediante el registro de auditoría de sesión. | – |
| pgaudit.log\$1catalog | Especifica que el registro de sesión se debe habilitar en el caso de que todas las relaciones de una instrucción se encuentren en pg\$1catalog. | – |
| pgaudit.log\$1level | Especifica el nivel de registro que se usará para las entradas de registro. | – |
| pgaudit.log\$1parameter | Especifica que el registro de auditoría debe incluir los parámetros que se pasaron con la instrucción. | – |
| pgaudit.log\$1relation | Especifica si el registro de auditoría de sesión debe crear una entrada de registro separada para cada relación (TABLE, VIEW, etc.) referenciada en una instrucción SELECT o DML. | – |
| pgaudit.log\$1statement\$1once | Especifica si el registro incluirá el texto de la instrucción y los parámetros con la primera entrada de registro para una combinación de instrucción o subinstrucción o con cada entrada. | – |
| pgaudit.role | Especifica el rol maestro que se usará para el registro de auditoría de objetos. | – |
| pg\$1bigm.enable\$1recheck | Especifica si se realiza una recomprobación, que es un proceso interno de búsqueda de texto completo. | on |
| pg\$1bigm.gin\$1key\$1limit | Especifica el número máximo de bigramas de la palabra clave de búsqueda que se utilizará para la búsqueda de texto completo. | 0 |
| pg\$1bigm.last\$1update | Informa de la última fecha de actualización del módulo pg\$1bigm. | 2013.11.22 |
| pg\$1bigm.similarity\$1limit | Especifica el umbral mínimo que usa la búsqueda de similitud. | 0.3 |
| pg\$1hint\$1plan.debug\$1print | Registra los resultados del análisis sintáctico de las pistas. | – |
| pg\$1hint\$1plan.enable\$1hint | Fuerza al planificador a usar los planes especificados en el comentario de la pista que precede a la consulta. | – |
| pg\$1hint\$1plan.enable\$1hint\$1table | Fuerza al planificador a no obtener la sugerencia mediante el uso de búsquedas en tablas. | – |
| pg\$1hint\$1plan.message\$1level | Nivel de mensaje de los mensajes de depuración. | – |
| pg\$1hint\$1plan.parse\$1messages | Nivel de mensaje de los errores de análisis. | – |
| pglogical.batch\$1inserts | Inserciones por lotes si es posible | – |
| pglogical.conflict\$1log\$1level | Establece el nivel de registro utilizado para registrar los conflictos resueltos. | – |
| pglogical.conflict\$1resolution | Establece el método que se usa para la resolución de conflictos de los conflictos resolubles. | – |
| pglogical.extra\$1connection\$1options | opciones de conexión para agregar a todas las conexiones de los nodos pares | – |
| pglogical.synchronous\$1commit | valor de confirmación sincrónica específico de pglogical | – |
| pglogical.use\$1spi | Usa SPI en lugar de la API de bajo nivel para aplicar los cambios | – |
| pgtle.clientauth\$1databases\$1to\$1skip | Lista de bases de datos que se deben omitir para utilizar la característica clientauth. | – |
| pgtle.clientauth\$1db\$1name | Controla qué base de datos se utiliza para la característica clientauth. | – |
| pgtle.clientauth\$1num\$1parallel\$1workers | Número de trabajadores en segundo plano utilizados para la característica clientauth. | – |
| pgtle.clientauth\$1users\$1to\$1skip | Lista de bases de datos que se deben omitir para la característica clientauth. | – |
| pgtle.enable\$1clientauth | Hablita la característica clientauth. | – |
| pgtle.passcheck\$1db\$1name | Establece qué base de datos se utiliza para característica passcheck en todo el clúster. | – |
| pg\$1prewarm.autoprewarm | Inicia el empleado de precalentamiento automático. | – |
| pg\$1prewarm.autoprewarm\$1interval | Establece el intervalo entre volcados de búferes compartidos | – |
| pg\$1similarity.block\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.block\$1threshold | Establece el umbral utilizado por la función de similitud Bloquear. | – |
| pg\$1similarity.block\$1tokenizer | Establece el tokenizador para la función de similitud de bloques. | – |
| pg\$1similarity.cosine\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.cosine\$1threshold | Establece el umbral utilizado por la función de similitud coseno. | – |
| pg\$1similarity.cosine\$1tokenizer | Establece el tokenizador para la función de similitud de coseno. | – |
| pg\$1similarity.dice\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.dice\$1threshold | Establece el umbral utilizado por la medida de similitud de dados. | – |
| pg\$1similarity.dice\$1tokenizer | Establece el tokenizador para la medida de similitud de dados. | – |
| pg\$1similarity.euclidean\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.euclidean\$1threshold | Establece el umbral utilizado por la medida de similitud euclidiana. | – |
| pg\$1similarity.euclidean\$1tokenizer | Establece el tokenizador para la medida de similitud euclidiana. | – |
| pg\$1similarity.hamming\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.hamming\$1threshold | Establece el umbral utilizado por la métrica de similitud de bloques. | – |
| pg\$1similarity.jaccard\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.jaccard\$1threshold | Establece el umbral utilizado por la medida de similitud Jaccard. | – |
| pg\$1similarity.jaccard\$1tokenizer | Establece el tokenizador para la medida de similitud de Jaccard. | – |
| pg\$1similarity.jaro\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.jaro\$1threshold | Establece el umbral utilizado por la medida de similitud Jaro. | – |
| pg\$1similarity.jarowinkler\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.jarowinkler\$1threshold | Establece el umbral utilizado por la medida de similitud Jarowinkler. | – |
| pg\$1similarity.levenshtein\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.levenshtein\$1threshold | Establece el umbral utilizado por la medida de similitud Levenshtein. | – |
| pg\$1similarity.matching\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.matching\$1threshold | Establece el umbral utilizado por la medida de similitud de coeficiente de coincidencia. | – |
| pg\$1similarity.matching\$1tokenizer | Establece el tokenizador para la medida de similitud de coeficiente de coincidencia. | – |
| pg\$1similarity.mongeelkan\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.mongeelkan\$1threshold | Establece el umbral utilizado por la medida de similitud Monge-Elkan. | – |
| pg\$1similarity.mongeelkan\$1tokenizer | Establece el tokenizador para la medida de similitud Monge-Elkan. | – |
| pg\$1similarity.nw\$1gap\$1penalty | Establece la penalización de separación utilizada por la medida de similitud Needleman-Wunsch. | – |
| pg\$1similarity.nw\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.nw\$1threshold | Establece el umbral utilizado por la medida de similitud Needleman-Wunsch. | – |
| pg\$1similarity.overlap\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.overlap\$1threshold | Establece el umbral utilizado por la medida de similitud de coeficiente de superposición. | – |
| pg\$1similarity.overlap\$1tokenizer | Establece el tokenizador para la medida de similitud del coeficiente de superposición. | – |
| pg\$1similarity.qgram\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.qgram\$1threshold | Establece el umbral utilizado por la medida de similitud Q-Gram. | – |
| pg\$1similarity.qgram\$1tokenizer | Establece el tokenizador para la medida Q-Gram. | – |
| pg\$1similarity.swg\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.swg\$1threshold | Establece el umbral utilizado por la medida de similitud Smith-Waterman-Gotoh. | – |
| pg\$1similarity.sw\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.sw\$1threshold | Establece el umbral utilizado por la medida de similitud de Smith-Waterman. | – |
| pg\$1stat\$1statements.max | Establece el número máximo de instrucciones rastreadas por pg\$1stat\$1statements. | – |
| pg\$1stat\$1statements.save | Guarda las estadísticas de pg\$1stat\$1statements a través de los apagados del servidor. | – |
| pg\$1stat\$1statements.track | Selecciona qué instrucciones rastrea pg\$1stat\$1statements. | – |
| pg\$1stat\$1statements.track\$1planning | Selecciona si la duración de la planificación se rastrea con pg\$1stat\$1statements. | – |
| pg\$1stat\$1statements.track\$1utility | Selecciona si los comandos de utilidad se rastrean mediante pg\$1stat\$1statements. | – |
| plan\$1cache\$1mode | Controla la selección del planificador del plan personalizado o genérico. | – |
| puerto | Establece el puerto TCP en el que escucha el servidor. | EndPointPort |
| postgis.gdal\$1enabled\$1drivers | Habilita o desactiva los controladores GDAL que se usan con PostGIS en Postgres 9.3.5 y versiones posteriores. | ENABLE\$1ALL |
| quote\$1all\$1identifiers | Al generar fragmentos de SQL, cite todos los identificadores. | – |
| random\$1page\$1cost | Establece la estimación de los planificadores del costo de una página de disco que no se recupera secuencialmente. | – |
| rdkit.dice\$1threshold | Umbral inferior de similitud de Dice. Las moléculas con una similitud inferior al umbral no son similares según la operación \$1. | – |
| rdkit.do\$1chiral\$1sss | En caso de que se tenga en cuenta la estereoquímica en la coincidencia de subestructuras. Si es falso, no se usa ninguna información de estereoquímica en las coincidencias de subestructuras. | – |
| rdkit.tanimoto\$1threshold | Umbral inferior de similitud de Tanimoto. Las moléculas con una similitud inferior al umbral no son similares según la operación %. | – |
| rds.accepted\$1password\$1auth\$1method | Fuerza la autenticación para las conexiones con contraseñas almacenadas localmente. | md5\$1scram |
| rds.adaptive\$1autovacuum | Parámetro RDS para habilitar o desactivar el autovacuum adaptativo. | 1 |
| rds.babelfish\$1status | Parámetro de RDS para habilitar o desactivar Babelfish for Aurora PostgreSQL. | apagar |
| rds.enable\$1plan\$1management | Habilita o desactiva la extensión apg\$1plan\$1mgmt. | 0 |
| rds.extensions | Lista de extensiones proporcionadas por 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 | Consulta los mensajes de registro de las acciones del usuario administrador de RDS en las bases de datos de los clientes. | – |
| rds.force\$1autovacuum\$1logging\$1level | Consulta los mensajes de registro relacionados con las operaciones de autovacuum. | WARNING |
| rds.force\$1ssl | Fuerza las conexiones SSL. | 0 |
| show rds.global\$1db\$1rpo; | (s) Umbral objetivo del punto de recuperación, en segundos, que bloquea las confirmaciones del usuario cuando se infringe. Este parámetro está destinado a bases de datos globales basadas en Aurora PostgreSQL. Para una base de datos no global, déjelo en el valor predeterminado. Para obtener más información sobre el uso de este parámetro, consulte [Administración de RPO para bases de datos globales basadas en Aurora PostgreSQL–](aurora-global-database-disaster-recovery.md#aurora-global-database-manage-recovery). | – |
| rds.logical\$1replication | Habilita la decodificación lógica. | 0 |
| rds.logically\$1replicate\$1unlogged\$1tables | Las tablas no registradas se replican de forma lógica. | 1 |
| rds.log\$1retention\$1period | Amazon RDS eliminará los registros de PostgreSQL que tengan una antigüedad superior a N minutos. | 4320 |
| rds.pg\$1stat\$1ramdisk\$1size | Tamaño del disco de estadísticas en MB. Un valor distinto de cero configurará el disco ramdisk. Este parámetro solo está disponible en la versión 14 e inferiores de Aurora PostgreSQL. | 0 |
| rds.rds\$1superuser\$1reserved\$1connections | Establece el número de ranuras de conexión reservadas para rds\$1superusers. Este parámetro solo está disponible en la versión 15 y anteriores. Para obtener más información, consulte la documentación de PostgreSQL sobre [reserved\$1connections](https://www.postgresql.org/docs/current/runtime-config-connection.html#GUC-RESERVED-CONNECTIONS). | 2 |
| rds.restrict\$1password\$1commands | Restringe los comandos relacionados con la contraseña a los miembros de rds\$1password | – |
| rds.superuser\$1variables | Lista de variables solo para superusuarios para las que elevamos las declaraciones de modificación de rds\$1superuser. | session\$1replication\$1role |
| recovery\$1init\$1sync\$1method | Establece el método para sincronizar el directorio de datos antes de la recuperación en caso de bloqueo. | syncfs |
| remove\$1temp\$1files\$1after\$1crash | Elimina los archivos temporales después de una caída del backend. | 0 |
| restart\$1after\$1crash | Reinicia el servidor después de una caída del backend. | – |
| row\$1security | Habilita la seguridad de las filas. | – |
| search\$1path | Define el orden de búsqueda del esquema para los nombres que no cumplen los requisitos del esquema. | – |
| seq\$1page\$1cost | Establece la estimación de los planificadores del costo de una página de disco obtenida secuencialmente. | – |
| session\$1replication\$1role | Define el comportamiento de las sesiones para los desencadenadores y las reglas de reescritura. | – |
| shared\$1buffers | (8kB) Establece el número de búferes de memoria compartida utilizados por el servidor. | SUM(DBInstanceClassMemory/12038,-50003) |
| shared\$1preload\$1libraries | Enumera las bibliotecas compartidas para precargar en el servidor. | pg\$1stat\$1statements |
| ssl | Habilita las conexiones SSL. | 1 |
| ssl\$1ca\$1file | Ubicación del archivo de autoridad del servidor SSL. | /rdsdbdata/rds-metadata/ca-cert.pem |
| ssl\$1cert\$1file | Ubicación del archivo de certificado del servidor SSL. | /rdsdbdata/rds-metadata/ca-cert.pem |
| ssl\$1ciphers | Establece la lista de cifrados TLS permitidos que se pueden usar en conexiones seguras. | – |
| ssl\$1crl\$1dir | Ubicación del directorio de lista de revocación de certificados SSL. | /rdsdbdata/rds-metadata/ssl\$1crl\$1dir/ |
| ssl\$1key\$1file | Ubicación del archivo de clave privada del servidor SSL | /rdsdbdata/rds-metadata/server-key.pem |
| ssl\$1max\$1protocol\$1version | Establece la versión máxima de protocolo SSL/TLS permitida | – |
| ssl\$1min\$1protocol\$1version | Establece la versión mínima de protocolo SSL/TLS permitida | TLSv1.2 |
| standard\$1conforming\$1strings | Hace que las cadenas ... traten las barras diagonales invertidas literalmente. | – |
| statement\$1timeout | (ms) Establece la duración máxima permitida de cualquier instrucción. | – |
| stats\$1temp\$1directory | Escribe los archivos de estadísticas temporales en el directorio especificado. | /rdsdbdata/db/pg\$1stat\$1tmp |
| superuser\$1reserved\$1connections | Establece el número de ranuras de conexión reservadas para los superusuarios. | 3 |
| synchronize\$1seqscans | Habilita los exámenes secuenciales sincronizados. | – |
| synchronous\$1commit | Define el nivel de sincronización de las transacciones actuales. | on |
| tcp\$1keepalives\$1count | Número máximo de retransmisiones de keepalive de TCP. | – |
| tcp\$1keepalives\$1idle | (s) Tiempo entre la emisión de keepalives de TCP. | – |
| tcp\$1keepalives\$1interval | (s) Tiempo entre retransmisiones de keepalives de TCP. | – |
| temp\$1buffers | (8kB) Establece el número máximo de búferes temporales utilizados por cada sesión. | – |
| temp\$1file\$1limit | Restringe la cantidad total de espacio en disco en kilobytes que un proceso PostgreSQL dado puede usar para archivos temporales, sin incluir el espacio usado para tablas temporales explícitas | -1 |
| temp\$1tablespaces | Define los espacios de tabla que se deben usar para las tablas temporales y los archivos de ordenación. | – |
| timezone | Define la zona horaria para visualizar e interpretar las marcas temporales. | UTC |
| track\$1activities | Recopila información sobre la ejecución de comandos. | – |
| track\$1activity\$1query\$1size | Define el tamaño reservado para pg\$1stat\$1activity.current\$1query en bytes. | 4096 |
| track\$1commit\$1timestamp | Recopila el tiempo de confirmación de transacciones. | – |
| track\$1counts | Recopila estadísticas sobre la actividad de la base de datos. | – |
| track\$1functions | Recopila estadísticas de nivel de función sobre la actividad de la base de datos. | pl |
| track\$1io\$1timing | Recopila estadísticas temporales sobre la actividad de E/S de la base de datos. | 1 |
| track\$1wal\$1io\$1timing | Recopila estadísticas temporales de la actividad de E/S de WAL. | – |
| transform\$1null\$1equals | Trata expr=NULL como expr IS NULL. | – |
| update\$1process\$1title | Actualiza el título del proceso para mostrar el comando SQL activo. | – |
| vacuum\$1cost\$1delay | Retardo del costo del vacío en milisegundos. | – |
| vacuum\$1cost\$1limit | Importe del costo del vacío disponible antes del periodo de reposo. | – |
| vacuum\$1cost\$1page\$1dirty | Costo del vacío para una página ensuciada por el vacío. | – |
| vacuum\$1cost\$1page\$1hit | Costo del vacío para una página encontrada en la caché del búfer. | – |
| vacuum\$1cost\$1page\$1miss | Costo del vacío para una página no encontrada en la caché del búfer. | 0 |
| vacuum\$1defer\$1cleanup\$1age | Número de transacciones por las que se debe aplazar la limpieza de VACUUM y HOT, si la hay. | – |
| vacuum\$1failsafe\$1age | Antigüedad con la que VACUUM debe activar el mecanismo a prueba de errores para evitar una interrupción del reinicio. | 1200000000 |
| vacuum\$1freeze\$1min\$1age | Antigüedad mínima con la que VACUUM debe congelar una fila de la tabla. | – |
| vacuum\$1freeze\$1table\$1age | Antigüedad con la que VACUUM debe escanear toda la tabla para congelar las tuplas. | – |
| vacuum\$1multixact\$1failsafe\$1age | Antigüedad exacta a la que el VACUUM debe activar el sistema de seguridad para evitar un corte de reinicio. | 1200000000 |
| vacuum\$1multixact\$1freeze\$1min\$1age | Antigüedad mínima con la que VACUUM debe congelar un MultiXactId en una fila de la tabla. | – |
| vacuum\$1multixact\$1freeze\$1table\$1age | Antigüedad de multixact con la que VACUUM debe escanear toda la tabla para congelar las tuplas. | – |
| wal\$1buffers | (8kB) Establece el número de búferes de páginas de disco en la memoria compartida para WAL. | – |
| wal\$1receiver\$1create\$1temp\$1slot | Establece si un receptor de WAL debe crear una ranura de replicación temporal si no se configura una ranura permanente. | 0 |
| wal\$1receiver\$1status\$1interval | (s) Establece el intervalo máximo entre los informes de estado del receptor de WAL al primario. | – |
| wal\$1receiver\$1timeout | (ms) Establece el tiempo máximo de espera para recibir datos del primario. | 30000 |
| wal\$1sender\$1timeout | (ms) Establece el tiempo máximo de espera para la replicación de WAL. | – |
| work\$1mem | (kB) Establece la memoria máxima que se utilizará para los espacios de trabajo de consulta. | – |
| xmlbinary | Define cómo se deben codificar los valores binarios en XML. | – |
| xmloption | Define si los datos XML de las operaciones implícitas de análisis y serialización se deben considerar documentos o fragmentos de contenido. | – |
## Parámetros de nivel de instancia de Aurora PostgreSQL
Puede ver los parámetros de nivel de instancia disponibles para una versión de Aurora PostgreSQL específica usando la consola de administración de AWS, la CLI de AWS o la API de Amazon RDS. Para obtener información sobre cómo ver los parámetros en grupos de parámetros de la base de datos de Aurora PostgreSQL en la consola de RDS, consulte [Visualización de los valores de parámetros de un grupo de parámetros de base de datos en Amazon Aurora](USER_WorkingWithParamGroups.Viewing.md).
Algunos parámetros en el nivel de instancia no están disponibles en todas las versiones y otros están en desuso. Para obtener información sobre cómo ver los parámetros de una versión específica de Aurora PostgreSQL, consulte [Visualización de los parámetros del clúster y de la base de datos de Aurora PostgreSQL](#AuroraPostgreSQL.Reference.ParameterGroups-viewing-parameters).
Por ejemplo, en la siguiente tabla se enumeran todos los parámetros que afectan a una instancia de base de datos concreta de un clúster de base de datos de Aurora PostgreSQL. Esta lista se generó al ejecutar el comando de AWS CLI [describe-db-parameters](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-parameters.html) con `default.aurora-postgresql14` para el valor `--db-parameter-group-name`.
Para obtener una lista de los parámetros de clúster de base de datos del mismo grupo de parámetros de base de datos predeterminado, consulte [Parámetros de nivel de clúster de Aurora PostgreSQL](#AuroraPostgreSQL.Reference.Parameters.Cluster).
| Nombre del parámetro | Descripción | Valor predeterminado |
| --- | --- | --- |
| apg\$1enable\$1batch\$1mode\$1function\$1execution | Habilita las funciones en modo lote para procesar conjuntos de filas a la vez. | – |
| apg\$1enable\$1correlated\$1any\$1transform | Permite que el planificador transforme la subconsulta ANY correlacionada (IN/NOT IN) en JOIN cuando sea posible. | – |
| apg\$1enable\$1function\$1migration | Permite al planificador migrar las funciones escalares elegibles a la cláusula FROM. | – |
| apg\$1enable\$1not\$1in\$1transform | Permite al planificador transformar la subconsulta NOT IN en ANTI JOIN cuando sea posible. | – |
| apg\$1enable\$1remove\$1redundant\$1inner\$1joins | Permite al planificador eliminar las uniones internas redundantes. | – |
| apg\$1enable\$1semijoin\$1push\$1down | Permite el uso de filtros semijoin para las uniones hash. | – |
| apg\$1plan\$1mgmt.capture\$1plan\$1baselines | Modo de línea base del plan de captura. manual - habilitar la captura del plan para cualquier sentencia SQL, desactivado - deshabilitar la captura del plan, automático - habilitar la captura del plan para las instrucciones en pg\$1stat\$1statements que cumplen los criterios de elegibilidad. | apagar |
| apg\$1plan\$1mgmt.max\$1databases | Establece el número máximo de bases de datos que se pueden administrar con apg\$1plan\$1mgmt. | 10 |
| apg\$1plan\$1mgmt.max\$1plans | Establece el número máximo de planes que se pueden almacenar en caché mediante apg\$1plan\$1mgmt. | 10000 |
| apg\$1plan\$1mgmt.plan\$1retention\$1period | Número máximo de días desde que un plan se usó por última vez antes de que un plan se elimine automáticamente. | 32 |
| apg\$1plan\$1mgmt.unapproved\$1plan\$1execution\$1threshold | Costo total estimado del plan por debajo del cual se ejecutará un plan no aprobado. | 0 |
| apg\$1plan\$1mgmt.use\$1plan\$1baselines | Use solo planes aprobados o fijos para las instrucciones administradas. | false |
| application\$1name | Define el nombre de la aplicación sobre la que informarán las estadísticas y los registros. | – |
| aurora\$1compute\$1plan\$1id | Supervisa los planes de ejecución de consultas para detectar los planes de ejecución que contribuyen a la carga actual de la base de datos y para hacer un seguimiento de las estadísticas de rendimiento de los planes de ejecución a lo largo del tiempo. Para obtener más información, consulte [Monitorización de planes de ejecución de consultas para Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraPostgreSQL.Monitoring.Query.Plans.html). | on |
| aurora\$1temp\$1space\$1size | (MB) Establece el tamaño del espacio asignado para los objetos temporales habilitados para lecturas optimizadas en clústeres optimizados para E/S de Aurora con clases de instancias compatibles. | DBInstanceClassMemory/524288 |
| authentication\$1timeout | Establece el tiempo máximo permitido para completar una autenticación del cliente. | – |
| auto\$1explain.log\$1analyze | Usa EXPLAIN ANALYZE para el registro de planes. | – |
| auto\$1explain.log\$1buffers | Usa los búferes de registro. | – |
| auto\$1explain.log\$1format | Usa el formato EXPLAIN para el registro del plan. | – |
| auto\$1explain.log\$1min\$1duration | Establece el tiempo mínimo de ejecución por encima del cual se registrarán los planes. | – |
| auto\$1explain.log\$1nested\$1statements | Registra las instrucciones anidadas. | – |
| auto\$1explain.log\$1timing | Recopila datos de cronometraje, no solo recuentos de filas. | – |
| auto\$1explain.log\$1triggers | Incluye estadísticas de desencadenado en los planes. | – |
| auto\$1explain.log\$1verbose | Usa EXPLAIN VERBOSE para el registro de planes. | – |
| auto\$1explain.sample\$1rate | Permite procesar una fracción de las consultas. | – |
| babelfishpg\$1tds.listen\$1addresses | Establece el nombre de host o las direcciones IP para escuchar el TDS. | \$1 |
| babelfishpg\$1tds.tds\$1debug\$1log\$1level | Establece el nivel de registro en TDS, 0 desactiva el registro | 1 |
| backend\$1flush\$1after | (8Kb) Número de páginas después de las cuales las escrituras realizadas anteriormente se vacían al disco. | – |
| bytea\$1output | Establece el formato de salida para bytea. | – |
| check\$1function\$1bodies | Comprueba los cuerpos de las funciones durante la ejecución de CREATE FUNCTION. | – |
| client\$1connection\$1check\$1interval | Establece el intervalo de tiempo entre las comprobaciones de desconexión mientras se ejecutan las consultas. | – |
| client\$1min\$1messages | Establece los niveles de mensajes que se envían al cliente. | – |
| config\$1file | Establece el archivo de configuración principal del servidor. | /rdsdbdata/config/postgresql.conf |
| constraint\$1exclusion | Habilita el planificador para que use restricciones con el fin de optimizar las consultas. | – |
| cpu\$1index\$1tuple\$1cost | Establece la estimación del planificador del costo de procesar cada entrada de índice durante un examen del índice. | – |
| cpu\$1operator\$1cost | Establece la estimación del planificador del costo de procesar cada operador o llamada a una función. | – |
| cpu\$1tuple\$1cost | Establece la estimación del planificador del costo de procesar cada tupla (fila). | – |
| cron.database\$1name | Establece la base de datos para almacenar las tablas de metadatos de pg\$1cron | postgres |
| cron.log\$1run | Registra todas las ejecuciones de trabajos en la tabla job\$1run\$1details | on |
| cron.log\$1statement | Registra todas las instrucciones cron antes de la ejecución. | apagar |
| cron.max\$1running\$1jobs | Número máximo de trabajos que pueden ejecutarse simultáneamente. | 5 |
| cron.use\$1background\$1workers | Habilita empleados en segundo plano para pg\$1cron | on |
| cursor\$1tuple\$1fraction | Establece la estimación de los planificadores de la fracción de filas de un cursor que se recuperará. | – |
| db\$1user\$1namespace | Habilita los nombres de usuario por base de datos. | – |
| deadlock\$1timeout | (ms) Establece el tiempo de espera de un bloqueo antes de comprobar si hay un bloqueo. | – |
| debug\$1pretty\$1print | Aplica una sangría a las visualizaciones del árbol de análisis y de planificación. | – |
| debug\$1print\$1parse | Registra el árbol de análisis de cada consulta. | – |
| debug\$1print\$1plan | Registra el plan de ejecución de cada consulta. | – |
| debug\$1print\$1rewritten | Registra el árbol de análisis reescrito de cada consulta. | – |
| default\$1statistics\$1target | Define el objetivo de estadística predeterminado. | – |
| default\$1transaction\$1deferrable | Define el estado diferible predeterminado de las nuevas transacciones. | – |
| default\$1transaction\$1isolation | Define el nivel de aislamiento de cada nueva transacción. | – |
| default\$1transaction\$1read\$1only | Define el estado de solo lectura predeterminado de las nuevas transacciones. | – |
| efective\$1cache\$1size | (8kB) Establece la suposición de los planificadores sobre el tamaño de la caché del disco. | SUM(DBInstanceClassMemory/12038,-50003 |
| effective\$1io\$1concurrency | Número de solicitudes simultáneas que el subsistema del disco puede gestionar de un modo eficiente. | – |
| enable\$1async\$1append | Habilita el uso de planes de append asíncronos por parte de los planificadores. | – |
| enable\$1bitmapscan | Habilita el uso de planes de examen de mapas de bits por parte de los planificadores. | – |
| enable\$1gathermerge | Habilita el uso de planes de fusión de recopilación por parte de los planificadores. | – |
| enable\$1hashagg | Habilita el uso de planes de agregación con hash por parte de los planificadores. | – |
| enable\$1hashjoin | Habilita el uso de planes de combinación con hash por parte de los planificadores. | – |
| enable\$1incremental\$1sort | Habilita el uso de pasos de ordenación incrementales por parte de los planificadores. | – |
| enable\$1indexonlyscan | Habilita el uso de planes de examen solo de índice por parte de los planificadores. | – |
| enable\$1indexscan | Habilita el uso de planes de examen de índice por parte de los planificadores. | – |
| enable\$1material | Habilita el uso de materialización por parte de los planificadores. | – |
| enable\$1memoize | Habilita el uso de memorización para los planificadores | – |
| enable\$1mergejoin | Habilita el uso de planes de combinación por fusión por parte de los planificadores. | – |
| enable\$1nestloop | Habilita el uso de planes de combinación de bucles anidados por parte de los planificadores. | – |
| enable\$1parallel\$1append | Habilita el uso de planes de append en paralelo por parte de los planificadores. | – |
| enable\$1parallel\$1hash | Habilita el uso de planes hash paralelos por parte de los planificadores. | – |
| enable\$1partition\$1pruning | Habilita la depuración de particiones en tiempo de planificación y de ejecución. | – |
| enable\$1partitionwise\$1aggregate | Habilita la agregación y agrupación de particiones. | – |
| enable\$1partitionwise\$1join | Habilita la combinación de particiones. | – |
| enable\$1seqscan | Habilita el uso de planes de examen secuencial por parte de los planificadores. | – |
| enable\$1sort | Habilita el uso de pasos de ordenación explícitos por parte de los planificadores. | – |
| enable\$1tidscan | Habilita el uso de planes de examen TID por parte de los planificadores. | – |
| escape\$1string\$1warning | Advierte sobre los escapes de barra invertida en los literales de cadena ordinarios. | – |
| exit\$1on\$1error | Termina la sesión en caso de error. | – |
| force\$1parallel\$1mode | Fuerza el uso de las facilidades de consulta paralela. | – |
| from\$1collapse\$1limit | Define el tamaño de la lista FROM por encima del cual las subconsultas no se contraen. | – |
| geqo | Habilita la optimización de consultas geneticas. | – |
| geqo\$1effort | GEQO: esfuerzo que se usa para definir el valor predeterminado de otros parámetros de GEQO. | – |
| geqo\$1generations | GEQO: número de iteraciones del algoritmo. | – |
| geqo\$1pool\$1size | GEQO: número de individuos de la población. | – |
| geqo\$1seed | GEQO: valor de inicialización para la selección de ruta aleatoria. | – |
| geqo\$1selection\$1bias | GEQO: presión selectiva dentro de la población. | – |
| geqo\$1threshold | Define el umbral de los elementos FROM por encima de los cuales se usa GEQO. | – |
| gin\$1fuzzy\$1search\$1limit | Define el resultado máximo permitido para la búsqueda exacta por GIN. | – |
| gin\$1pending\$1list\$1limit | (kB) Establece el tamaño máximo de la lista pendiente para el índice de GIN. | – |
| hash\$1mem\$1multiplicador | Múltiplo de work\$1mem que se utilizará para las tablas hash. | – |
| hba\$1file | Establece el archivo de configuración de HBA de servidores. | /rdsdbdata/config/pg\$1hba.conf |
| hot\$1standby\$1feedback | Permite la retroalimentación de una espera activa al primario que evitará conflictos de consulta. | on |
| ident\$1file | Establece el archivo de configuración de ident de servidores. | /rdsdbdata/config/pg\$1hba.conf |
| in\$1timeout | (ms) Establece la duración máxima permitida de cualquier transacción en espera. | 86400000 |
| idle\$1session\$1timeout | Finaliza cualquier sesión que haya estado inactiva (es decir, en espera de una consulta por parte de un cliente), pero no dentro de una transacción abierta, durante más tiempo del especificado | – |
| join\$1collapse\$1limit | Define el tamaño de la lista FROM por encima del cual las construcciones JOIN no se aplanan. | – |
| lc\$1messages | Define el idioma en el que se muestran los mensajes. | – |
| listen\$1addresses | Establece el nombre de host o las direcciones IP para escuchar. | \$1 |
| lo\$1compat\$1privileges | Habilita el modo de compatibilidad con versiones pasadas para las comprobaciones de privilegios en objetos grandes. | 0 |
| log\$1connections | Registra cada conexión realizada correctamente. | – |
| log\$1destination | Establece el destino de la salida del registro del servidor. | stderr |
| log\$1directory | Establece el directorio de destino para los archivos de registro. | /rdsdbdata/log/error |
| log\$1disconnections | Registra el final de una sesión, incluida su duración. | – |
| log\$1duration | Registra la duración de cada instrucción de SQL completada. | – |
| log\$1error\$1verbosity | Define el detalle de los mensajes registrados. | – |
| log\$1executor\$1stats | Escribe las estadísticas de rendimiento del ejecutor en el registro del servidor. | – |
| log\$1file\$1mode | Establece los permisos de los archivos de registro. | 0644 |
| log\$1filename | Define el patrón del nombre de archivo de los archivos de registro. | postgresql.log.%Y-%m-%d-%H%M |
| logging\$1collector | Inicia un subproceso para capturar el resultado de stderr o csvlogs en archivos de registro. | 1 |
| log\$1hostname | Registra el nombre del host en los registros de conexión. | 0 |
| logical\$1decoding\$1work\$1mem | (kB) Cada búfer de reordenamiento interno puede usar esta cantidad de memoria antes de volcar en el disco. | – |
| log\$1line\$1prefix | Controla la información prefijada en cada línea de registro. | %t: %r: %u@%d: %p]: |
| log\$1lock\$1waits | Registra las esperas de bloqueo largas. | – |
| log\$1min\$1duration\$1sample | (ms) Establece el tiempo mínimo de ejecución a partir del cual se registrará una muestra de instrucciones. El muestreo se determina mediante log\$1statement\$1sample\$1rate. | – |
| log\$1min\$1duration\$1statement | (ms) Establece el tiempo mínimo de ejecución por encima del cual se registrarán las instrucciones. | – |
| log\$1min\$1error\$1statement | Hace que se registren todas las instrucciones que generen un error por encima de este nivel. | – |
| log\$1min\$1messages | Define los niveles de los mensajes que se registran. | – |
| log\$1parameter\$1max\$1length | (B) Al registrar instrucciones limita los valores de los parámetros registrados a los primeros N bytes. | – |
| log\$1parameter\$1max\$1length\$1on\$1error | (B) Cuando se informa de un error, limita los valores de los parámetros registrados a los primeros N bytes. | – |
| log\$1parser\$1stats | Escribe las estadísticas de rendimiento del analizador en el registro del servidor. | – |
| log\$1planner\$1stats | Escribe las estadísticas de rendimiento del planificador en el registro del servidor. | – |
| log\$1replication\$1commands | Registra cada comando de replicación. | – |
| log\$1rotation\$1age | (min) La rotación automática del archivo de registro se producirá después de N minutos. | 60 |
| log\$1rotation\$1size | (kB) La rotación automática del archivo de registro se producirá después de N kilobytes. | 100000 |
| log\$1statement | Define el tipo de declaraciones que se deben registrar. | – |
| log\$1statement\$1sample\$1rate | Fracción de instrucciones que exceden la muestra de log\$1min\$1duration que se registrará. | – |
| log\$1statement\$1stats | Escribe las estadísticas de rendimiento acumulativas en el registro del servidor. | – |
| log\$1temp\$1files | (kB) Registra el uso de archivos temporales mayores a este número de kilobytes. | – |
| log\$1timezone | Establece la zona horaria que se usará en los mensajes de registro. | UTC |
| log\$1truncate\$1on\$1rotation | Permite truncar los archivos de registro existentes con el mismo nombre durante la rotación del registro. | 0 |
| maintenance\$1io\$1concurrency | Una variante de effective\$1io\$1concurrency que se utiliza para trabajos de mantenimiento. | 1 |
| maintenance\$1work\$1mem | (kB) Establece la memoria máxima que se puede usar para las operaciones de mantenimiento | GREATEST(DBInstanceClassMemory/63963136\$11024,65536) |
| max\$1connections | Define el número máximo de conexiones simultáneas. | LEAST(DBInstanceClassMemory/9531392,5000) |
| max\$1files\$1per\$1process | Define el número máximo de archivos abiertos simultáneamente para cada proceso del servidor. | – |
| max\$1locks\$1per\$1transaction | Define el número máximo de bloqueos por transacción. | 64 |
| max\$1parallel\$1maintenance\$1workers | Establece el número máximo de procesos en paralelo por operación de mantenimiento. | – |
| max\$1parallel\$1workers | Establece el número máximo de empleados en paralelo que pueden estar activos a la vez. | GREATEST(\$1DBInstanceVCPU/2,8) |
| max\$1parallel\$1workers\$1per\$1gather | Establece el número máximo de procesos en paralelo por nodo ejecutor. | – |
| max\$1pred\$1locks\$1per\$1page | Establece el número máximo de tuplas bloqueadas por predicado por página. | – |
| max\$1pred\$1locks\$1per\$1relation | Establece el número máximo de páginas y tuplas bloqueadas por predicado por relación. | – |
| max\$1pred\$1locks\$1per\$1transaction | Define el número máximo de bloqueos de predicado por transacción. | – |
| max\$1slot\$1wal\$1keep\$1size | (MB) Las ranuras de replicación se marcarán como fallidas, y los segmentos se liberarán para su eliminación o reciclaje si esta cantidad de espacio está ocupada por la WAL en el disco. | – |
| max\$1stack\$1depth | (kB) Establece la profundidad máxima de la pila, en kilobytes. | 6144 |
| max\$1standby\$1streaming\$1delay | (ms) Establece el retardo máximo antes de cancelar las consultas cuando un servidor en espera activa está procesando datos de WAL en flujo. | 14000 |
| max\$1worker\$1processes | Establece el número máximo de procesos de empleados que se ejecutan simultáneamente. | GREATEST(\$1DBInstanceVCPU\$12,8) |
| min\$1dynamic\$1shared\$1memory | (MB) Cantidad de memoria compartida dinámica reservada al inicio. | – |
| min\$1parallel\$1index\$1scan\$1size | (8kB) Establece la cantidad mínima de datos de índice para un examen en paralelo. | – |
| min\$1parallel\$1table\$1scan\$1size | (8kB) Establece la cantidad mínima de datos de tabla para un examen en paralelo. | – |
| old\$1snapshot\$1threshold | (min) Tiempo antes de que una instantánea se vuelva demasiado antigua para leer las páginas modificadas después de la captura de la instantánea. | – |
| parallel\$1leader\$1participation | Controla si Gather y Gather Merge también ejecutan subplanes. | – |
| parallel\$1setup\$1cost | Establece la estimación de los planificadores del costo de iniciar procesos de empleados para la consulta paralela. | – |
| parallel\$1tuple\$1cost | Establece la estimación de los planificadores del costo de pasar cada tupla (fila) del empleado al backend maestro. | – |
| pgaudit.log | Especifica qué clases de instrucciones se registrarán mediante el registro de auditoría de sesión. | – |
| pgaudit.log\$1catalog | Especifica que el registro de sesión se debe habilitar en el caso de que todas las relaciones de una instrucción se encuentren en pg\$1catalog. | – |
| pgaudit.log\$1level | Especifica el nivel de registro que se usará para las entradas de registro. | – |
| pgaudit.log\$1parameter | Especifica que el registro de auditoría debe incluir los parámetros que se pasaron con la instrucción. | – |
| pgaudit.log\$1relation | Especifica si el registro de auditoría de sesión debe crear una entrada de registro separada para cada relación (TABLE, VIEW, etc.) referenciada en una instrucción SELECT o DML. | – |
| pgaudit.log\$1statement\$1once | Especifica si el registro incluirá el texto de la instrucción y los parámetros con la primera entrada de registro para una combinación de instrucción o subinstrucción o con cada entrada. | – |
| pgaudit.role | Especifica el rol maestro que se usará para el registro de auditoría de objetos. | – |
| pg\$1bigm.enable\$1recheck | Especifica si se realiza una recomprobación, que es un proceso interno de búsqueda de texto completo. | on |
| pg\$1bigm.gin\$1key\$1limit | Especifica el número máximo de bigramas de la palabra clave de búsqueda que se utilizará para la búsqueda de texto completo. | 0 |
| pg\$1bigm.last\$1update | Informa de la última fecha de actualización del módulo pg\$1bigm. | 2013.11.22 |
| pg\$1bigm.similarity\$1limit | Especifica el umbral mínimo que usa la búsqueda de similitud. | 0.3 |
| pg\$1hint\$1plan.debug\$1print | Registra los resultados del análisis sintáctico de las pistas. | – |
| pg\$1hint\$1plan.enable\$1hint | Fuerza al planificador a usar los planes especificados en el comentario de la pista que precede a la consulta. | – |
| pg\$1hint\$1plan.enable\$1hint\$1table | Fuerza al planificador a no obtener la sugerencia mediante el uso de búsquedas en tablas. | – |
| pg\$1hint\$1plan.message\$1level | Nivel de mensaje de los mensajes de depuración. | – |
| pg\$1hint\$1plan.parse\$1messages | Nivel de mensaje de los errores de análisis. | – |
| pglogical.batch\$1inserts | Inserciones por lotes si es posible | – |
| pglogical.conflict\$1log\$1level | Establece el nivel de registro utilizado para registrar los conflictos resueltos. | – |
| pglogical.conflict\$1resolution | Establece el método que se usa para la resolución de conflictos de los conflictos resolubles. | – |
| pglogical.extra\$1connection\$1options | opciones de conexión para agregar a todas las conexiones de los nodos pares | – |
| pglogical.synchronous\$1commit | valor de confirmación sincrónica específico de pglogical | – |
| pglogical.use\$1spi | Usa SPI en lugar de la API de bajo nivel para aplicar los cambios | – |
| pg\$1similarity.block\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.block\$1threshold | Establece el umbral utilizado por la función de similitud Bloquear. | – |
| pg\$1similarity.block\$1tokenizer | Establece el tokenizador para la función de similitud de bloques. | – |
| pg\$1similarity.cosine\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.cosine\$1threshold | Establece el umbral utilizado por la función de similitud coseno. | – |
| pg\$1similarity.cosine\$1tokenizer | Establece el tokenizador para la función de similitud de coseno. | – |
| pg\$1similarity.dice\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.dice\$1threshold | Establece el umbral utilizado por la medida de similitud de dados. | – |
| pg\$1similarity.dice\$1tokenizer | Establece el tokenizador para la medida de similitud de dados. | – |
| pg\$1similarity.euclidean\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.euclidean\$1threshold | Establece el umbral utilizado por la medida de similitud euclidiana. | – |
| pg\$1similarity.euclidean\$1tokenizer | Establece el tokenizador para la medida de similitud euclidiana. | – |
| pg\$1similarity.hamming\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.hamming\$1threshold | Establece el umbral utilizado por la métrica de similitud de bloques. | – |
| pg\$1similarity.jaccard\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.jaccard\$1threshold | Establece el umbral utilizado por la medida de similitud Jaccard. | – |
| pg\$1similarity.jaccard\$1tokenizer | Establece el tokenizador para la medida de similitud de Jaccard. | – |
| pg\$1similarity.jaro\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.jaro\$1threshold | Establece el umbral utilizado por la medida de similitud Jaro. | – |
| pg\$1similarity.jarowinkler\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.jarowinkler\$1threshold | Establece el umbral utilizado por la medida de similitud Jarowinkler. | – |
| pg\$1similarity.levenshtein\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.levenshtein\$1threshold | Establece el umbral utilizado por la medida de similitud Levenshtein. | – |
| pg\$1similarity.matching\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.matching\$1threshold | Establece el umbral utilizado por la medida de similitud de coeficiente de coincidencia. | – |
| pg\$1similarity.matching\$1tokenizer | Establece el tokenizador para la medida de similitud de coeficiente de coincidencia. | – |
| pg\$1similarity.mongeelkan\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.mongeelkan\$1threshold | Establece el umbral utilizado por la medida de similitud Monge-Elkan. | – |
| pg\$1similarity.mongeelkan\$1tokenizer | Establece el tokenizador para la medida de similitud Monge-Elkan. | – |
| pg\$1similarity.nw\$1gap\$1penalty | Establece la penalización de separación utilizada por la medida de similitud Needleman-Wunsch. | – |
| pg\$1similarity.nw\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.nw\$1threshold | Establece el umbral utilizado por la medida de similitud Needleman-Wunsch. | – |
| pg\$1similarity.overlap\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.overlap\$1threshold | Establece el umbral utilizado por la medida de similitud de coeficiente de superposición. | – |
| pg\$1similarity.overlap\$1tokenizer | Establece el tokenizador para la medida de similitud del coeficiente de superposición. | – |
| pg\$1similarity.qgram\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.qgram\$1threshold | Establece el umbral utilizado por la medida de similitud Q-Gram. | – |
| pg\$1similarity.qgram\$1tokenizer | Establece el tokenizador para la medida Q-Gram. | – |
| pg\$1similarity.swg\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.swg\$1threshold | Establece el umbral utilizado por la medida de similitud Smith-Waterman-Gotoh. | – |
| pg\$1similarity.sw\$1is\$1normalized | Establece si el valor del resultado está normalizado o no. | – |
| pg\$1similarity.sw\$1threshold | Establece el umbral utilizado por la medida de similitud de Smith-Waterman. | – |
| pg\$1stat\$1statements.max | Establece el número máximo de instrucciones rastreadas por pg\$1stat\$1statements. | – |
| pg\$1stat\$1statements.save | Guarda las estadísticas de pg\$1stat\$1statements a través de los apagados del servidor. | – |
| pg\$1stat\$1statements.track | Selecciona qué instrucciones rastrea pg\$1stat\$1statements. | – |
| pg\$1stat\$1statements.track\$1planning | Selecciona si la duración de la planificación se rastrea con pg\$1stat\$1statements. | – |
| pg\$1stat\$1statements.track\$1utility | Selecciona si los comandos de utilidad se rastrean mediante pg\$1stat\$1statements. | – |
| postgis.gdal\$1enabled\$1drivers | Habilita o desactiva los controladores GDAL que se usan con PostGIS en Postgres 9.3.5 y versiones posteriores. | ENABLE\$1ALL |
| quote\$1all\$1identifiers | Al generar fragmentos de SQL, cite todos los identificadores. | – |
| random\$1page\$1cost | Establece la estimación de los planificadores del costo de una página de disco que no se recupera secuencialmente. | – |
| rds.enable\$1memory\$1management | Mejora las capacidades de administración de memoria en las versiones 12.17, 13.13, 14.10, 15.5 y superiores de Aurora PostgreSQL para evitar los problemas de estabilidad y los reinicios de las bases de datos causados por la falta de memoria libre. Para obtener más información, consulte [Administración de memoria mejorada en Aurora PostgreSQLLimitación](AuroraPostgreSQL.BestPractices.memory.management.md). | True |
| rds.force\$1admin\$1logging\$1level | Consulta los mensajes de registro de las acciones del usuario administrador de RDS en las bases de datos de los clientes. | – |
| rds.log\$1retention\$1period | Amazon RDS eliminará los registros de PostgreSQL que tengan una antigüedad superior a N minutos. | 4320 |
| rds.memory\$1allocation\$1guard | Mejora las capacidades de administración de memoria en las versiones 11.21, 12.16, 13.12, 14.9, 15.4 y anteriores de Aurora PostgreSQL para evitar los problemas de estabilidad y los reinicios de las bases de datos causados por la falta de memoria libre. Para obtener más información, consulte [Administración de memoria mejorada en Aurora PostgreSQLLimitación](AuroraPostgreSQL.BestPractices.memory.management.md). | False |
| rds.pg\$1stat\$1ramdisk\$1size | Tamaño del disco de estadísticas en MB. Un valor distinto de cero configurará el disco ramdisk. | 0 |
| rds.rds\$1superuser\$1reserved\$1connections | Establece el número de ranuras de conexión reservadas para rds\$1superusers. Este parámetro solo está disponible en la versión 15 y anteriores. Para obtener más información, consulte la documentación de PostgreSQL sobre [reserved\$1connections](https://www.postgresql.org/docs/current/runtime-config-connection.html#GUC-RESERVED-CONNECTIONS). | 2 |
| rds.superuser\$1variables | Lista de variables solo para superusuarios para las que elevamos las declaraciones de modificación de rds\$1superuser. | session\$1replication\$1role |
| remove\$1temp\$1files\$1after\$1crash | Elimina los archivos temporales después de una caída del backend. | 0 |
| restart\$1after\$1crash | Reinicia el servidor después de una caída del backend. | – |
| row\$1security | Habilita la seguridad de las filas. | – |
| search\$1path | Define el orden de búsqueda del esquema para los nombres que no cumplen los requisitos del esquema. | – |
| seq\$1page\$1cost | Establece la estimación de los planificadores del costo de una página de disco obtenida secuencialmente. | – |
| session\$1replication\$1role | Define el comportamiento de las sesiones para los desencadenadores y las reglas de reescritura. | – |
| shared\$1buffers | (8kB) Establece el número de búferes de memoria compartida utilizados por el servidor. | SUM(DBInstanceClassMemory/12038,-50003) |
| shared\$1preload\$1libraries | Enumera las bibliotecas compartidas para precargar en el servidor. | pg\$1stat\$1statements |
| ssl\$1ca\$1file | Ubicación del archivo de autoridad del servidor SSL. | /rdsdbdata/rds-metadata/ca-cert.pem |
| ssl\$1cert\$1file | Ubicación del archivo de certificado del servidor SSL. | /rdsdbdata/rds-metadata/ca-cert.pem |
| ssl\$1crl\$1dir | Ubicación del directorio de lista de revocación de certificados SSL. | /rdsdbdata/rds-metadata/ssl\$1crl\$1dir/ |
| ssl\$1key\$1file | Ubicación del archivo de clave privada del servidor SSL | /rdsdbdata/rds-metadata/server-key.pem |
| standard\$1conforming\$1strings | Hace que las cadenas ... traten las barras diagonales invertidas literalmente. | – |
| statement\$1timeout | (ms) Establece la duración máxima permitida de cualquier instrucción. | – |
| stats\$1temp\$1directory | Escribe los archivos de estadísticas temporales en el directorio especificado. | /rdsdbdata/db/pg\$1stat\$1tmp |
| superuser\$1reserved\$1connections | Establece el número de ranuras de conexión reservadas para los superusuarios. | 3 |
| synchronize\$1seqscans | Habilita los exámenes secuenciales sincronizados. | – |
| tcp\$1keepalives\$1count | Número máximo de retransmisiones de keepalive de TCP. | – |
| tcp\$1keepalives\$1idle | (s) Tiempo entre la emisión de keepalives de TCP. | – |
| tcp\$1keepalives\$1interval | (s) Tiempo entre retransmisiones de keepalives de TCP. | – |
| temp\$1buffers | (8kB) Establece el número máximo de búferes temporales utilizados por cada sesión. | – |
| temp\$1file\$1limit | Restringe la cantidad total de espacio en disco en kilobytes que un proceso PostgreSQL dado puede usar para archivos temporales, sin incluir el espacio usado para tablas temporales explícitas | -1 |
| temp\$1tablespaces | Define los espacios de tabla que se deben usar para las tablas temporales y los archivos de ordenación. | – |
| track\$1activities | Recopila información sobre la ejecución de comandos. | – |
| track\$1activity\$1query\$1size | Define el tamaño reservado para pg\$1stat\$1activity.current\$1query en bytes. | 4096 |
| track\$1counts | Recopila estadísticas sobre la actividad de la base de datos. | – |
| track\$1functions | Recopila estadísticas de nivel de función sobre la actividad de la base de datos. | pl |
| track\$1io\$1timing | Recopila estadísticas temporales sobre la actividad de E/S de la base de datos. | 1 |
| transform\$1–\$1equals | Treats expr=– as expr IS –. | – |
| update\$1process\$1title | Actualiza el título del proceso para mostrar el comando SQL activo. | – |
| wal\$1receiver\$1status\$1interval | (s) Establece el intervalo máximo entre los informes de estado del receptor de WAL al primario. | – |
| work\$1mem | (kB) Establece la memoria máxima que se utilizará para los espacios de trabajo de consulta. | – |
| xmlbinary | Define cómo se deben codificar los valores binarios en XML. | – |
| xmloption | Define si los datos XML de las operaciones implícitas de análisis y serialización se deben considerar documentos o fragmentos de contenido. | – |
# Eventos de espera de Amazon Aurora PostgreSQL
A continuación, encontrará eventos de espera frecuentes de Aurora PostgreSQL. Para obtener más información sobre los eventos de espera y activar el clúster de bases de datos de Aurora PostgreSQL, consulte [Ajuste con eventos de espera de Aurora PostgreSQL](AuroraPostgreSQL.Tuning.md).
**Activity:ArchiverMain**
El proceso de archivador está esperando la actividad.
**Activity:AutoVacuumMain**
El proceso del iniciador de autovacuum está esperando la actividad.
**Activity:BgWriterHibernate**
El proceso de escritor en segundo plano está hibernando mientras se espera la actividad.
**Activity:BgWriterMain**
El proceso de escritor en segundo plano está esperando la actividad.
**Activity:CheckpointerMain**
El proceso del verificador de puntos está esperando la actividad.
**Activity:LogicalApplyMain**
El proceso de aplicación de replicación lógica está esperando la actividad.
**Activity:LogicalLauncherMain**
El proceso del iniciador de replicación lógica está esperando la actividad.
**Activity:PgStatMain**
El proceso del recopilador de estadísticas está a la espera de actividad.
**Activity:RecoveryWalAll**
Un proceso está esperando el registro de escritura anticipada (WAL) de una transmisión en recuperación.
**Activity:RecoveryWalStream**
El proceso de inicio está esperando a que llegue el registro de escritura anticipada (WAL) durante la recuperación del streaming.
**Activity:SysLoggerMain**
El proceso de syslogger está esperando la actividad.
**Activity:WalReceiverMain**
El proceso de recepción del registro de escritura anticipada (WAL) está esperando la actividad.
**Activity:WalSenderMain**
El proceso de envío del registro de escritura anticipada (WAL) está esperando la actividad.
**Activity:WalWriterMain**
El proceso de escritura del registro de escritura anticipada (WAL) está esperando la actividad.
**BufferPin:BufferPin**
Un proceso está esperando para adquirir un pin exclusivo en un buffer.
**Client:GSSOpenServer**
Un proceso está esperando para leer los datos del cliente mientras se establece una sesión de interfaz de programación de aplicaciones del servicio de seguridad genérico (GSSAPI).
**Client:ClientRead**
Un proceso de backend está esperando para recibir datos de un cliente de PostgreSQL. Para obtener más información, consulte [Client:ClientRead](apg-waits.clientread.md).
**Client:ClientWrite**
Un proceso de backend está esperando para enviar más datos a un cliente de PostgreSQL. Para obtener más información, consulte [Client:ClientWrite](apg-waits.clientwrite.md).
**Client:LibPQWalReceiverConnect**
Un proceso está esperando en el receptor del registro de escritura anticipada (WAL) para establecer la conexión con el servidor remoto.
**Client:LibPQWalReceiverReceive**
Un proceso está esperando en el receptor del registro de escritura anticipada (WAL) para recibir datos del servidor remoto.
**Client:SSLOpenServer**
Un proceso está esperando la Capa de sockets seguros (SSL) mientras se intenta la conexión.
**Client:WalReceiverWaitStart**
Un proceso está esperando a que el proceso de inicio envíe datos iniciales para la replicación del streaming.
**Client:WalSenderWaitForWAL**
Un proceso está esperando a que el registro de escritura anticipada (WAL) se vacíe en el proceso de remitente de WAL.
**Client:WalSenderWriteData**
Un proceso está esperando cualquier actividad al procesar las respuestas del receptor de registro de escritura anticipada (WAL) en el proceso de remitente de WAL.
**CPU**
Un proceso de backend está activo en la CPU o a la espera de ella. Para obtener más información, consulte [CPU](apg-waits.cpu.md).
**Extension:extension**
Un proceso de backend está esperando una condición definida por una extensión o módulo.
**IO:AuroraEnhancedLogicalWALRead**
Un proceso de backend consiste en obtener registros de registro del volumen de captura de datos de cambio (CDC).
**IO:AuroraOptimizedReadsCacheRead**
Un proceso está esperando una lectura de la caché por niveles de lecturas optimizadas porque la página no está disponible en la memoria compartida.
**IO:AuroraOptimizedReadsCacheSegmentTruncate**
Un proceso está esperando a que se termine un archivo de segmento de caché por niveles de lecturas optimizadas.
**IO:AuroraOptimizedReadsCacheWrite**
El proceso de escritor en segundo plano está esperando para escribir en la caché por niveles de lecturas optimizadas.
**IO:AuroraStorageLogAllocate**
Una sesión está asignando metadatos y se prepara para escribir un registro de transacciones.
**IO:BufFileRead**
Cuando las operaciones requieren más memoria que la cantidad definida por los parámetros de memoria de trabajo, el motor crea archivos temporales en el disco. Este evento de espera se produce cuando las operaciones leen desde los archivos temporales. Para obtener más información, consulte [IO:BufFileRead y IO:BufFileWrite](apg-waits.iobuffile.md).
**IO:BufFileWrite**
Cuando las operaciones requieren más memoria que la cantidad definida por los parámetros de memoria de trabajo, el motor crea archivos temporales en el disco. Este evento de espera se produce cuando las operaciones escriben desde los archivos temporales. Para obtener más información, consulte [IO:BufFileRead y IO:BufFileWrite](apg-waits.iobuffile.md).
**IO:ControlFileRead**
Un proceso está esperando una lectura desde el archivo `pg_control`.
**IO:ControlFileSync**
Un proceso está esperando a que el archivo `pg_control` se almacene de forma permanente.
**IO:ControlFileSyncUpdate**
Un proceso está esperando a que una actualización del archivo `pg_control` se almacene de forma permanente.
**IO:ControlFileWrite**
Un proceso está esperando una escritura en el archivo `pg_control`.
**IO:ControlFileWriteUpdate**
Un proceso está esperando una escritura para actualizar el archivo `pg_control`.
**IO:CopyFileRead**
Un proceso está esperando una lectura durante una operación de copia de archivos.
**IO:CopyFileWrite**
Un proceso está esperando una escritura durante una operación de copia de archivos.
**IO:DataFileExtend**
Un proceso está esperando a que se amplíe un archivo de datos de relación.
**IO:DataFileFlush**
Un proceso está esperando a que un archivo de datos de relación se almacene de forma permanente.
**IO:DataFileImmediateSync**
Un proceso está esperando una sincronización inmediata de un archivo de datos de relación a un almacenamiento permanente.
**IO:DataFilePrefetch**
Un proceso está esperando una captura previa asíncrona desde un archivo de datos de relación.
**IO:DataFileSync**
Un proceso está esperando a que los cambios en un archivo de datos de relación se almacenen de forma permanente.
**IO:DataFileRead**
Un proceso de backend intentó encontrar una página en los búferes compartidos, no la encontró y, por lo tanto, la leyó desde el almacenamiento. Para obtener más información, consulte [IO:DataFileRead](apg-waits.iodatafileread.md).
**IO:DataFileTruncate**
Un proceso está esperando a que se trunque un archivo de datos de relación.
**IO:DataFileWrite**
Un proceso está esperando una escritura en un archivo de datos de relación.
**IO:DSMFillZeroWrite**
Un proceso está esperando para escribir cero bytes en un archivo de copia de seguridad de memoria compartida dinámica.
**IO:LockFileAddToDataDirRead**
Un proceso está esperando una lectura mientras se agrega una línea al archivo de bloqueo del directorio de datos.
**IO:LockFileAddToDataDirSync**
Un proceso está esperando a que los datos se almacenen de forma permanente mientras se agrega una línea al archivo de bloqueo del directorio de datos.
**IO:LockFileAddToDataDirWrite**
Un proceso está esperando una escritura mientras se agrega una línea al archivo de bloqueo del directorio de datos.
**IO:LockFileCreateRead**
Un proceso está esperando para escribir mientras se crea el archivo de bloqueo del directorio de datos.
**IO:LockFileCreateSync**
Un proceso está esperando a que los datos se almacenen de forma permanente mientras se crea el archivo de bloqueo del directorio de datos.
**IO:LockFileCreateWrite**
Un proceso está esperando una escritura mientras se crea el archivo de bloqueo del directorio de datos.
**IO:LockFileReCheckDataDirRead**
Un proceso está esperando una lectura durante la nueva verificación del archivo de bloqueo del directorio de datos.
**IO:LogicalRewriteCheckpointSync**
Un proceso está esperando a que las asignaciones de reescritura lógica se almacenen de forma permanente durante un punto de verificación.
**IO:LogicalRewriteMappingSync**
Un proceso está esperando a que los datos de asignación se almacenen de forma permanente durante una rescritura lógica.
**IO:LogicalRewriteMappingWrite**
Un proceso está esperando una escritura de los datos de asignación durante una reescritura lógica.
**IO:LogicalRewriteSync**
Un proceso está esperando a que las asignaciones de rescritura lógica se almacenen de forma permanente.
**IO:LogicalRewriteTruncate**
Un proceso está esperando el truncamiento de los datos de asignación durante una reescritura lógica.
**IO:LogicalRewriteWrite**
Un proceso está esperando una escritura de las asignaciones de rescritura lógica.
**IO:RelationMapRead**
Un proceso está esperando una lectura del archivo de asignación de relación.
**IO:RelationMapSync**
Un proceso está esperando a que el archivo de asignación de relación se almacene de forma permanente.
**IO:RelationMapWrite**
Un proceso está esperando una escritura en el archivo de asignación de relación.
**IO:ReorderBufferRead**
Un proceso está esperando una lectura durante la administración del búfer de reordenamiento.
**IO:ReorderBufferWrite**
Un proceso está esperando una escritura durante la administración del búfer de reordenamiento.
**IO:ReorderLogicalMappingRead**
Un proceso está a la espera de una lectura de una asignación lógica durante la administración del búfer de reordenamiento.
**IO:ReplicationSlotRead**
Un proceso está esperando una lectura desde un archivo de control de ranuras de replicación.
**IO:ReplicationSlotRestoreSync**
Un proceso está esperando a que un archivo de control de ranuras de replicación se almacene de forma permanente mientras lo restaura en la memoria.
**IO:ReplicationSlotSync**
Un proceso está esperando a que un archivo de control de ranuras de replicación se almacene de forma permanente.
**IO:ReplicationSlotWrite**
Un proceso está esperando una escritura en un archivo de control de ranuras de replicación.
**IO:SLRUFlushSync**
Un proceso está esperando a que los datos simples de uso menos reciente (SLRU) se almacenen de forma permanente durante un punto de verificación o cierre de la base de datos.
**IO:SLRURead**
Un proceso está esperando una lectura de una página simple de uso menos reciente (SLRU).
**IO:SLRUSync**
Un proceso está esperando a que los datos simples de uso menos reciente (SLRU) se almacenen de forma permanente después de una escritura de página.
**IO:SLRUWrite**
Un proceso está esperando una escritura de una página simple de uso menos reciente (SLRU).
**IO:SnapbuildRead**
Un proceso está esperando una lectura de una instantánea del catálogo histórico en serie.
**IO:SnapbuildSync**
Un proceso está esperando a que una instantánea del catálogo histórico en serie se almacene de forma permanente.
**IO:SnapbuildWrite**
Un proceso está esperando una escritura de una instantánea del catálogo histórico en serie.
**IO:TimelineHistoryFileSync**
Un proceso está esperando a que un archivo de historial de cronología recibido a través de la replicación del streaming se almacene de forma permanente.
**IO:TimelineHistoryFileWrite**
Un proceso está esperando una escritura de un archivo de historial de cronología a través de la replicación del streaming.
**IO:TimelineHistoryRead**
Un proceso está esperando una lectura de un archivo de historial de cronología.
**IO:TimelineHistorySync**
Un proceso está esperando a que un archivo de historial de cronología recién creado se almacene de forma permanente.
**IO:TimelineHistoryWrite**
Un proceso está esperando una escritura de un archivo de historial de cronología recién creado.
**IO:TwophaseFileRead**
Un proceso está esperando una lectura de un archivo de estado de dos fases.
**IO:TwophaseFileSync**
Un proceso está esperando a que un archivo de estado de dos fases se almacene de forma permanente.
**IO:TwophaseFileWrite**
Un proceso está esperando una escritura de un archivo de estado de dos fases.
**IO:WALBootstrapSync**
Un proceso está esperando a que el registro de escritura anticipada (WAL) se almacene de forma permanente durante el proceso de arranque.
**IO:WALBootstrapWrite**
Un proceso está esperando una escritura de una página del registro de escritura anticipada (WAL) durante el proceso de arranque.
**IO:WALCopyRead**
Un proceso está esperando una lectura al crear un nuevo segmento del registro de escritura anticipada (WAL) mediante la copia de uno existente.
**IO:WALCopySync**
Un proceso está esperando a que un nuevo segmento del registro de escritura anticipada (WAL) creado mediante la copia de uno existente se almacene de forma permanente.
**IO:WALCopyWrite**
Un proceso está esperando una escritura al crear un nuevo segmento del registro de escritura anticipada (WAL) mediante la copia de uno existente.
**IO:WALInitSync**
Un proceso está esperando a que un archivo de registro de escritura anticipada (WAL) recién inicializado se almacene de forma permanente.
**IO:WALInitWrite**
Un proceso está esperando una escritura mientras se inicializa un nuevo archivo de registro de escritura anticipada (WAL).
**IO:WALRead**
Un proceso está esperando una lectura desde un archivo de registro de escritura anticipada (WAL).
**IO:WALSenderTimelineHistoryRead**
Un proceso está esperando una lectura desde un archivo de historial de cronología durante un comando de cronología de remitente de WAL.
**IO:WALSync**
Un proceso está esperando a que un archivo de registro de escritura anticipada (WAL) se almacene de forma permanente.
**IO:WALSyncMethodAssign**
Un proceso está esperando a que los datos se almacenen de forma permanente mientras se asigna un nuevo método de sincronización del registro de escritura anticipada (WAL).
**IO:WALWrite**
Un proceso está esperando una escritura en un archivo de registro de escritura anticipada (WAL).
**IO:XactSync**
Un evento de backend está esperando a que el subsistema de almacenamiento de Aurora reconozca la confirmación de una transacción regular, o bien la confirmación o restauración de una transacción preparada. Para obtener más información, consulte [IO:XactSync](apg-waits.xactsync.md).
**IPC:AuroraLogicalSchemaUpdate**
Dos procesos de backend están intentando insertar la misma entrada en la caché del esquema. Un proceso continuará mientras el otro espera a que se complete.
**IPC:AuroraOptimizedReadsCacheWriteStop**
Un proceso está esperando a que el escritor en segundo plano deje de escribir en la caché por niveles con lecturas optimizadas.
**IPC:BackupWaitWalArchive**
Un proceso está esperando los archivos de registro de escritura anticipada (WAL) necesarios para archivar correctamente una copia de seguridad.
**IPC:BgWorkerShutdown**
Un proceso está esperando a que un proceso de trabajo en segundo plano se cierre.
**IPC:BgWorkerStartup**
Un proceso está esperando a que un proceso de trabajo en segundo plano se inicie.
**IPC:BtreePage**
Un proceso está esperando a que esté disponible el número de páginas necesario para continuar un análisis paralelo de árbol B.
**IPC:CheckpointDone**
Un proceso está esperando a que se complete un punto de verificación.
**IPC:CheckpointStart**
Un proceso está esperando a que se inicie un punto de verificación.
**IPC:ClogGroupUpdate**
Un proceso está esperando a que el líder del grupo actualice el estado de la transacción al final de una transacción.
**IPC:DamRecordTxAck**
Un proceso de backend generó un evento de transmisiones de actividad de la base de datos y está esperando a que el evento se vuelva permanente. Para obtener más información, consulte [IPC:DamRecordTxAck](apg-waits.ipcdamrecordtxac.md).
**IPC:ExecuteGather**
Un proceso está esperando la actividad desde un proceso secundario mientras se ejecuta un nodo del plan de Gather.
**IPC:Hash/Batch/Allocating**
Un proceso está esperando a que un participante hash paralelo elegido asigne una tabla hash.
**IPC:Hash/Batch/Electing**
Un proceso elige un participante hash paralelo para asignar una tabla hash.
**IPC:Hash/Batch/Loading**
Un proceso está esperando a que otros participantes hash paralelos terminen de cargar una tabla hash.
**IPC:Hash/Build/Allocating**
Un proceso está esperando a que un participante hash paralelo elegido asigne la tabla hash inicial.
**IPC:Hash/Build/Electing**
Un proceso elige un participante hash paralelo para asignar la tabla hash inicial.
**IPC:Hash/Build/HashingInner**
Un proceso está esperando a que otros participantes hash paralelos terminen las operaciones hash de la relación interna.
**IPC:Hash/Build/HashingOuter**
Un proceso está esperando a que otros participantes hash paralelos terminen la partición de la relación externa.
**IPC:Hash/GrowBatches/Allocating**
Un proceso está esperando a que un participante hash paralelo elegido asigne más lotes.
**IPC:Hash/GrowBatches/Deciding**
Un proceso elige un participante hash paralelo para decidir sobre el crecimiento futuro de los lotes.
**IPC:Hash/GrowBatches/Electing**
Un proceso elige un participante hash paralelo para asignar más lotes.
**IPC:Hash/GrowBatches/Finishing**
Un proceso está esperando a que un participante hash paralelo elegido decida sobre el crecimiento futuro de los lotes.
**IPC:Hash/GrowBatches/Repartitioning**
Un proceso está esperando a que otros participantes hash paralelos terminen la creación de nuevas particiones.
**IPC:Hash/GrowBuckets/Allocating**
Un proceso está esperando a que un participante hash paralelo elegido termine de asignar más buckets.
**IPC:Hash/GrowBuckets/Electing**
Un proceso elige un participante hash paralelo para asignar más buckets.
**IPC:Hash/GrowBuckets/Reinserting**
Un proceso está esperando a que otros participantes hash paralelos terminen de insertar tuplas en los buckets nuevos.
**IPC:HashBatchAllocate**
Un proceso está esperando a que un participante hash paralelo elegido asigne una tabla hash.
**IPC:HashBatchElect**
Un proceso está esperando para elegir un participante hash paralelo para asignar una tabla hash.
**IPC:HashBatchLoad**
Un proceso está esperando a que otros participantes hash paralelos terminen de cargar una tabla hash.
**IPC:HashBuildAllocate**
Un proceso está esperando a que un participante hash paralelo elegido asigne la tabla hash inicial.
**IPC:HashBuildElect**
Un proceso está esperando para elegir un participante hash paralelo para asignar la tabla hash inicial.
**IPC:HashBuildHashInner**
Un proceso está esperando a que otros participantes hash paralelos terminen las operaciones hash de la relación interna.
**IPC:'HashBuildHashOuter**
Un proceso está esperando a que otros participantes hash paralelos terminen la partición de la relación externa.
**IPC:HashGrowBatchesAllocate**
Un proceso está esperando a que un participante hash paralelo elegido asigne más lotes.
**IPC:'HashGrowBatchesDecide**
Un proceso está esperando para elegir un participante hash paralelo para decidir sobre el crecimiento futuro de los lotes.
**IPC:HashGrowBatchesElect**
Un proceso está esperando para elegir un participante hash paralelo para asignar más lotes.
**IPC:HashGrowBatchesFinish**
Un proceso está esperando a que un participante hash paralelo elegido decida sobre el crecimiento futuro de los lotes.
**IPC:HashGrowBatchesRepartition**
Un proceso está esperando a que otros participantes hash paralelos terminen la creación de nuevas particiones.
**IPC:HashGrowBucketsAllocate**
Un proceso está esperando a que un participante hash paralelo elegido termine de asignar más buckets.
**IPC:HashGrowBucketsElect**
Un proceso está esperando para elegir un participante hash paralelo para asignar más buckets.
**IPC:HashGrowBucketsReinsert**
Un proceso está esperando a que otros participantes hash paralelos terminen de insertar tuplas en los buckets nuevos.
**IPC:LogicalSyncData**
Un proceso está esperando a que un servidor remoto de replicación lógica envíe datos para la sincronización de la tabla inicial.
**IPC:LogicalSyncStateChange**
Un proceso está esperando a que un servidor remoto de replicación lógica cambie de estado.
**IPC:MessageQueueInternal**
Un proceso está esperando a que se adjunte otro proceso a una cola de mensajes compartida.
**IPC:MessageQueuePutMessage**
Un proceso está esperando para escribir un mensaje de protocolo en una cola de mensajes compartida.
**IPC:MessageQueueReceive**
Un proceso está esperando para recibir bytes de una cola de mensajes compartida.
**IPC:MessageQueueSend**
Un proceso está esperando para enviar bytes a una cola de mensajes compartida.
**IPC:ParallelBitmapScan**
Un proceso está esperando a que se inicialice un análisis de mapa de bits paralelo.
**IPC:ParallelCreateIndexScan**
Un proceso está esperando a que los procesos de trabajo de CREATE INDEX paralelos terminen un análisis de montón.
**IPC:ParallelFinish**
Un proceso está esperando a que los procesos de trabajo paralelos terminen de calcular.
**IPC:ProcArrayGroupUpdate**
Un proceso está esperando a que el líder del grupo elimine el ID de la transacción al final de una transacción.
**IPC:ProcSignalBarrier**
Un proceso está esperando a que todos los backend procesen un evento de barrera.
**IPC:Promote**
Un proceso está esperando la promoción en espera.
**IPC:RecoveryConflictSnapshot**
Un proceso está esperando la resolución de conflictos de recuperación para una limpieza vacuum.
**IPC:RecoveryConflictTablespace**
Un proceso está esperando a la resolución de conflictos de recuperación para eliminar un espacio de tabla.
**IPC:RecoveryPause**
Un proceso está esperando a que se reanude la recuperación.
**IPC:ReplicationOriginDrop**
Un proceso está esperando a que un origen de replicación quede inactivo para que se pueda eliminar.
**IPC:ReplicationSlotDrop**
Un proceso está esperando a que una ranura de replicación quede inactiva para que pueda eliminarse.
**IPC:SafeSnapshot**
Un proceso está esperando a obtener una instantánea válida para una transacción READ ONLY DEFERRABLE.
**IPC:SyncRep**
Un proceso está esperando la confirmación de un servidor remoto durante la replicación síncrona.
**IPC:XactGroupUpdate**
Un proceso está esperando a que el líder del grupo actualice el estado de la transacción al final de una transacción.
**Lock:advisory**
Un proceso de backend solicitó un bloqueo de asesoría y lo está esperando. Para obtener más información, consulte [Lock:advisory](apg-waits.lockadvisory.md).
**Lock:extend**
Un proceso de backend está esperando a que se libere un bloqueo para que pueda extender una relación. Este bloqueo es necesario porque solo un proceso de backend puede extender una relación a la vez. Para obtener más información, consulte [Lock:extend](apg-waits.lockextend.md).
**Lock:frozenid**
Un proceso está esperando para actualizar `pg_database.datfrozenxid` y `pg_database.datminmxid`.
**Lock:object**
Un proceso está esperando para obtener un bloqueo en un objeto de base de datos sin relación.
**Lock:page**
Un proceso está esperando para obtener un bloqueo en una página de una relación.
**Lock:Relation**
Un proceso de backend está esperando para adquirir un bloqueo de una relación bloqueada por otra transacción. Para obtener más información, consulte [Lock:Relation](apg-waits.lockrelation.md).
**Lock:spectoken**
Un proceso está esperando para obtener un bloqueo de inserción especulativa.
**Lock:speculative token**
Un proceso está esperando para adquirir un bloqueo de inserción especulativa.
**Lock:transactionid**
Una transacción está esperando un bloqueo a nivel de fila. Para obtener más información, consulte [Lock:transactionid](apg-waits.locktransactionid.md).
**Lock:tuple**
Un proceso de backend está esperando para adquirir un bloqueo en una tupla, mientras que otro proceso de backend mantiene un bloqueo conflictivo en la misma tupla. Para obtener más información, consulte [Lock:tuple](apg-waits.locktuple.md).
**Lock:userlock**
Un proceso está esperando para obtener un bloqueo de usuario.
**Lock:virtualxid**
Un proceso está esperando para obtener un bloqueo de ID de transacción virtual.
**LWLock:AddinShmemInit**
Un proceso está esperando para administrar la asignación de espacio de una extensión en la memoria compartida.
**LWLock:AddinShmemInitLock**
Un proceso está esperando para administrar la asignación de espacio de la memoria compartida.
**LWLock:async**
Un proceso está esperando la E/S de un búfer asíncrono (notificación).
**LWLock:AsyncCtlLock**
Un proceso está esperando para leer o actualizar un estado de notificación compartida.
**LWLock:AsyncQueueLock**
Un proceso está esperando para leer o actualizar los mensajes de notificación.
**LWLock:AuroraOptimizedReadsCacheMapping**
Un proceso está esperando para asociar un bloque de datos a una página en la caché por niveles de lecturas optimizadas.
**LWLock:AutoFile**
Un proceso está esperando para actualizar el archivo `postgresql.auto.conf`.
**LWLock:AutoFileLock**
Un proceso está esperando para actualizar el archivo `postgresql.auto.conf`.
**LWLock:Autovacuum**
Un proceso está esperando para leer o actualizar el estado actual de los procesos de trabajo de autovacuum.
**LWLock:AutovacuumLock**
Un proceso de trabajo o iniciador de autovacuum está esperando para actualizar o leer el estado actual de los procesos de trabajo de autovacuum.
**LWLock:AutovacuumSchedule**
Un proceso está esperando para garantizar que una tabla seleccionada para autovacuum aún necesita la operación vacuum.
**LWLock:AutovacuumScheduleLock**
Un proceso está esperando para garantizar que la tabla que seleccionó para una operación vacuum aún la necesita.
**LWLock:BackendRandomLock**
Un proceso está esperando para generar un número aleatorio.
**LWLock:BackgroundWorker**
Un proceso está esperando para leer o actualizar el estado del proceso de trabajo en segundo plano.
**LWLock:BackgroundWorkerLock**
Un proceso está esperando para leer o actualizar el estado del proceso de trabajo en segundo plano.
**LWLock:BtreeVacuum**
Un proceso está esperando para leer o actualizar la información relacionada con vacuum de un índice del árbol B.
**LWLock:BtreeVacuumLock**
Un proceso está esperando para leer o actualizar la información relacionada con vacuum de un índice del árbol B.
**LWLock:buffer\$1content**
Un proceso de backend está esperando para adquirir un bloqueo ligero sobre el contenido de un búfer de memoria compartida. Para obtener más información, consulte [LWLock:buffer\$1content (BufferContent)](apg-waits.lockbuffercontent.md).
**LWLock:buffer\$1mapping**
Un proceso de backend está esperando para asociar un bloque de datos a un búfer del grupo de búferes compartido. Para obtener más información, consulte [LWLock:buffer\$1mapping](apg-waits.lwl-buffer-mapping.md).
**LWLock:BufferIO**
Un proceso de backend quiere leer una página en la memoria compartida. El proceso está esperando a que otros procesos finalicen su E/S de la página. Para obtener más información, consulte [LWLock:BufferIO (IPC:BufferIO)](apg-waits.lwlockbufferio.md).
**LWLock:Checkpoint**
Un proceso está esperando para iniciar un punto de verificación.
**LWLock:CheckpointLock**
Un proceso está esperando para hacer un punto de verificación.
**LWLock:CheckpointerComm**
Un proceso está esperando para administrar las solicitudes de `fsync`.
**LWLock:CheckpointerCommLock**
Un proceso está esperando para administrar las solicitudes de `fsync`.
**LWLock:clog**
Un proceso está esperando la E/S en un búfer de obstrucción (estado de transacción).
**LWLock:CLogControlLock**
Un proceso está esperando para leer o actualizar el estado de la transacción.
**LWLock:CLogTruncationLock**
Un proceso está esperando para ejecutar `txid_status` o actualizar el ID de transacción más antiguo que tenga disponible.
**LWLock:commit\$1timestamp**
Un proceso está esperando la E/S en un búfer de marca de tiempo de confirmación.
**LWLock:CommitTs**
Un proceso está esperando para leer o actualizar el último valor establecido para una marca de tiempo de confirmación de transacción.
**LWLock:CommitTsBuffer**
Un proceso está esperando la E/S en un búfer simple de uso menos reciente (SLRU) para una marca de tiempo de confirmación.
**LWLock:CommitTsControlLock**
Un proceso está esperando para leer o actualizar las marcas de tiempo de confirmación de transacciones.
**LWLock:CommitTsLock**
Un proceso está esperando para leer o actualizar el último valor establecido para la marca de tiempo de la transacción.
**LWLock:CommitTsSLRU**
Un proceso está esperando para acceder a la caché simple de uso menos reciente (SLRU) para una marca de tiempo de confirmación.
**LWLock:ControlFile**
Un proceso está esperando para leer o actualizar el archivo `pg_control` o crear un nuevo archivo de registro de escritura anticipada (WAL).
**LWLock:ControlFileLock**
Un proceso está esperando para leer o actualizar el archivo de control o la creación de un nuevo archivo de registro de escritura anticipada (WAL).
**LWLock:DynamicSharedMemoryControl**
Un proceso está esperando para leer o actualizar la información de asignación dinámica de memoria compartida.
**LWLock:DynamicSharedMemoryControlLock**
Un proceso está esperando para leer o actualizar el estado de la memoria compartida dinámica.
**LWLock:lock\$1manager**
Un proceso de backend está esperando para agregar o examinar los bloqueos de los procesos de backend. O bien está esperando para unirse o salir de un grupo de bloqueo utilizado por una consulta paralela. Para obtener más información, consulte [LWLock:lock\$1manager](apg-waits.lw-lock-manager.md).
**LWLock:LockFastPath**
Un proceso está esperando para leer o actualizar la información de bloqueo de método rápido de un proceso.
**LWLock:LogicalRepWorker**
Un proceso está esperando para leer o actualizar el estado de los procesos de trabajo de replicación lógica.
**LWLock:LogicalRepWorkerLock**
Un proceso está esperando a que finalice una acción en un proceso de trabajo de replicación lógica.
**LWLock:LogicalSchemaCache**
Un proceso ha modificado la caché del esquema.
**LWLock:multixact\$1member**
Un proceso está esperando la E/S en un búfer de multixact\$1member.
**LWLock:multixact\$1offset**
Un proceso está esperando la E/S en un búfer de desplazamiento de multixact.
**LWLock:MultiXactGen**
Un proceso está esperando para leer o actualizar el estado de multixact compartido.
**LWLock:MultiXactGenLock**
Un proceso está esperando para leer o actualizar un estado de multixact compartido.
**LWLock:MultiXactMemberBuffer**
Un proceso está esperando la E/S en un búfer simple de uso menos reciente (SLRU) para un miembro de multixact. Para obtener más información, consulte [LWLock:MultiXact](apg-waits.lwlockmultixact.md).
**LWLock:MultiXactMemberControlLock**
Un proceso está esperando para leer o actualizar las asignaciones de miembros de multixact.
**LWLock:MultiXactMemberSLRU**
Un proceso está esperando para acceder a la caché simple de uso menos reciente (SLRU) de un miembro de multixact. Para obtener más información, consulte [LWLock:MultiXact](apg-waits.lwlockmultixact.md).
**LWLock:MultiXactOffsetBuffer**
Un proceso está esperando la E/S en un búfer simple de uso menos reciente (SLRU) para un desplazamiento de multixact. Para obtener más información, consulte [LWLock:MultiXact](apg-waits.lwlockmultixact.md).
**LWLock:MultiXactOffsetControlLock**
Un proceso está esperando para leer o actualizar las asignaciones de desplazamiento de multixact.
**LWLock:MultiXactOffsetSLRU**
Un proceso está esperando para acceder a la caché simple de uso menos reciente (SLRU) de un desplazamiento de multixact. Para obtener más información, consulte [LWLock:MultiXact](apg-waits.lwlockmultixact.md).
**LWLock:MultiXactTruncation**
Un proceso está esperando para leer o truncar información de multixact.
**LWLock:MultiXactTruncationLock**
Un proceso está esperando para leer o truncar información de multixact.
**LWLock:NotifyBuffer**
Un proceso está esperando la E/S en el búfer simple de uso menos reciente (SLRU) para un mensaje de NOTIFY.
**LWLock:NotifyQueue**
Un proceso está esperando para leer o actualizar los mensajes de NOTIFY.
**LWLock:NotifyQueueTail**
Un proceso está esperando para actualizar un límite en el almacenamiento de mensajes de NOTIFY.
**LWLock:NotifyQueueTailLock**
Un proceso está esperando para actualizar el límite del almacenamiento de mensajes de notificación.
**LWLock:NotifySLRU**
Un proceso está esperando para acceder a la caché simple de uso menos reciente (SLRU) para un mensaje de NOTIFY.
**LWLock:OidGen**
Un proceso está esperando para asignar un ID de objeto (OID) nuevo.
**LWLock:OidGenLock**
Un proceso está esperando para asignar un ID de objeto (OID).
**LWLock:oldserxid**
Un proceso está esperando la E/S en un búfer de oldserxid.
**LWLock:OldSerXidLock**
Un proceso está esperando para leer o registrar transacciones serializables en conflicto.
**LWLock:OldSnapshotTimeMap**
Un proceso está esperando para leer o actualizar la información antigua del control de instantáneas.
**LWLock:OldSnapshotTimeMapLock**
Un proceso está esperando para leer o actualizar la información antigua del control de instantáneas.
**LWLock:parallel\$1append**
Un proceso está esperando para elegir el siguiente subplan durante la ejecución del plan anexado paralelo.
**LWLock:parallel\$1hash\$1join**
Un proceso está esperando para asignar o intercambiar un fragmento de memoria o actualizar los contadores durante la ejecución de un plan hash paralelo.
**LWLock:parallel\$1query\$1dsa**
Un proceso está esperando a que se bloquee la asignación dinámica de memoria compartida para una consulta paralela.
**LWLock:ParallelAppend**
Un proceso está esperando para elegir el siguiente subplan durante la ejecución del plan anexado paralelo.
**LWLock:ParallelHashJoin**
Un proceso está esperando para sincronizar los procesos de trabajo durante la ejecución del plan para una combinación hash paralela.
**Lwlock:ParallelQueryDSA**
Un proceso está esperando la asignación dinámica de memoria compartida para una consulta paralela.
**Lwlock:PerSessionDSA**
Un proceso está esperando la asignación dinámica de memoria compartida para una consulta paralela.
**Lwlock:PerSessionRecordType**
Un proceso está esperando para acceder a la información de una consulta paralela acerca de los tipos compuestos.
**Lwlock:PerSessionRecordTypmod**
Un proceso está esperando para acceder a la información de una consulta paralela acerca de los modificadores de tipo que identifican tipos de registros anónimos.
**Lwlock:PerXactPredicateList**
Un proceso está esperando para acceder a la lista de bloqueos de predicados que la transacción serializable actual mantiene durante una consulta paralela.
**Lwlock:predicate\$1lock\$1manager**
Un proceso está esperando para agregar o examinar la información de bloqueo de predicados.
**Lwlock:PredicateLockManager**
Un proceso está esperando para acceder a la información de bloqueo de predicado utilizada por las transacciones serializables.
**Lwlock:proc**
Un proceso está esperando para leer o actualizar la información de bloqueo de método rápido.
**LWLock:ProcArray**
Un proceso está esperando para acceder a las estructuras de datos compartidas por proceso (normalmente, para obtener una instantánea o informar del ID de transacción de una sesión).
**LWLock:ProcArrayLock**
Un proceso está esperando para obtener una instantánea o borrar un ID de transacción al final de una transacción.
**LWLock:RelationMapping**
Un proceso está esperando para leer o actualizar un archivo `pg_filenode.map` (utilizado para hacer un seguimiento de las asignaciones de nodos de archivo de determinados catálogos del sistema).
**LWLock:RelationMappingLock**
Un proceso está esperando para actualizar el archivo de asignación de relaciones utilizado para almacenar la asignación de catálogo a nodo de archivo.
**LWLock:RelCacheInit**
Un proceso está esperando para leer o actualizar un archivo `pg_internal.init` (un archivo de inicialización de la caché de relaciones).
**LWLock:RelCacheInitLock**
Un proceso está esperando para leer o escribir un archivo de inicialización de la caché de relaciones.
**LWLock:replication\$1origin**
Un proceso está esperando para leer o actualizar el progreso de la replicación.
**LWLock:replication\$1slot\$1io**
Un proceso está esperando la E/S en una ranura de replicación.
**LWLock:ReplicationOrigin**
Un proceso está esperando para crear, eliminar o utilizar un origen de replicación.
**LWLock:ReplicationOriginLock**
Un proceso está esperando para configurar, eliminar o utilizar un origen de replicación.
**LWLock:ReplicationOriginState**
Un proceso está esperando para leer o actualizar el progreso de un origen de replicación.
**LWLock:ReplicationSlotAllocation**
Un proceso está esperando para asignar o liberar una ranura de replicación.
**LWLock:ReplicationSlotAllocationLock**
Un proceso está esperando para asignar o liberar una ranura de replicación.
**LWLock:ReplicationSlotControl**
Un proceso está esperando para leer o actualizar un estado de ranura de replicación.
**LWLock:ReplicationSlotControlLock**
Un proceso está esperando para leer o actualizar el estado de la ranura de replicación.
**LWLock:ReplicationSlotIO**
Un proceso está esperando la E/S en una ranura de replicación.
**LWLock:SerialBuffer**
Un proceso está esperando la E/S en un búfer simple de uso menos reciente (SLRU) para un conflicto de transacciones serializable.
**LWLock:SerializableFinishedList**
Un proceso está esperando para acceder a la lista de transacciones serializables terminadas.
**LWLock:SerializableFinishedListLock**
Un proceso está esperando para acceder a la lista de transacciones serializables terminadas.
**LWLock:SerializablePredicateList**
Un proceso está esperando para acceder a la lista de bloqueos de predicados almacenados por las transacciones serializables.
**LWLock:SerializablePredicateLockListLock**
Un proceso está esperando para hacer una operación en una lista de bloqueos que las transacciones serializables mantienen.
**LWLock:SerializableXactHash**
Un proceso está esperando para leer o actualizar la información acerca de las transacciones serializables.
**LWLock:SerializableXactHashLock**
Un proceso está esperando para recuperar o almacenar información acerca de las transacciones serializables.
**LWLock:SerialSLRU**
Un proceso está esperando para acceder a la caché simple de uso menos reciente (SLRU) para un conflicto de transacciones serializable.
**LWLock:SharedTidBitmap**
Un proceso está esperando para acceder a un mapa de bits de identificador de tupla compartido (TID) durante un análisis de índice de mapa de bits paralelo.
**LWLock:SharedTupleStore**
Un proceso está esperando para acceder a un almacén de tuplas compartido durante una consulta paralela.
**LWLock:ShmemIndex**
Un proceso está esperando para buscar o asignar espacio en la memoria compartida.
**LWLock:ShmemIndexLock**
Un proceso está esperando para buscar o asignar espacio en la memoria compartida.
**LWLock:SInvalRead**
Un proceso está esperando para recuperar mensajes de la cola de invalidación de catálogos compartida.
**LWLock:SInvalReadLock**
Un proceso está esperando para recuperar o eliminar mensajes de una cola de invalidación compartida.
**LWLock:SInvalWrite**
Un proceso está esperando para agregar un mensaje de la cola de invalidación de catálogos compartida.
**LWLock:SInvalWriteLock**
Un proceso está esperando para agregar un mensaje en una cola de invalidación compartida.
**LWLock:SyncRep**
Un proceso está esperando para leer o actualizar información acerca del estado de la replicación síncrona.
**LWLock:SyncRepLock**
Un proceso está esperando para leer o actualizar información acerca de las réplicas síncronas.
**LWLock:SyncScan**
Un proceso está esperando para seleccionar la ubicación inicial de un análisis de tabla sincronizado.
**LWLock:SyncScanLock**
Un proceso está esperando para obtener la ubicación inicial de una tabla para los análisis sincronizados.
**LWLock:TablespaceCreate**
Un proceso está esperando para crear o eliminar un espacio de tabla.
**LWLock:TablespaceCreateLock**
Un proceso está esperando para crear o eliminar el espacio de tabla.
**LWLock:tbm**
Un proceso está esperando un bloqueo de iterador compartido en un mapa de bits de árbol (TBM).
**LWLock:TwoPhaseState**
Un proceso está esperando para leer o actualizar el estado de las transacciones preparadas.
**LWLock:TwoPhaseStateLock**
Un proceso está esperando para leer o actualizar el estado de las transacciones preparadas.
**LWLock:wal\$1insert**
Un proceso está esperando para insertar el registro de escritura anticipada (WAL) en un búfer de memoria.
**LWLock:WALBufMapping**
Un proceso está esperando para reemplazar una página en los búferes del registro de escritura anticipada (WAL).
**LWLock:WALBufMappingLock**
Un proceso está esperando para reemplazar una página en los búferes del registro de escritura anticipada (WAL).
**LWLock:WALInsert**
Un proceso está esperando para insertar los datos del registro de escritura anticipada (WAL) en un búfer de memoria.
**LWLock:WALWrite**
Un proceso está esperando a que se escriban los búferes del registro de escritura anticipada (WAL) en el disco.
**LWLock:WALWriteLock**
Un proceso está esperando a que se escriban los búferes del registro de escritura anticipada (WAL) en el disco.
**LWLock:WrapLimitsVacuum**
Un proceso está esperando para actualizar los límites del ID de transacción y el consumo de multixact.
**LWLock:WrapLimitsVacuumLock**
Un proceso está esperando para actualizar los límites del ID de transacción y el consumo de multixact.
**LWLock:XactBuffer**
Un proceso está esperando la E/S en un búfer simple de uso menos reciente (SLRU) para un estado de transacción.
**LWLock:XactSLRU**
Un proceso está esperando para acceder a la caché simple de uso menos reciente (SLRU) para un estado de transacción.
**LWLock:XactTruncation**
Un proceso está esperando para ejecutar pg\$1xact\$1status o actualizar el ID de transacción más antiguo que tiene disponible.
**LWLock:XidGen**
Un proceso está esperando para asignar un nuevo ID de transacción.
**LWLock:XidGenLock**
Un proceso está esperando para asignar un ID de transacción.
**Timeout:BaseBackupThrottle**
Un proceso está esperando durante la copia de seguridad base cuando hicieron limitaciones controladas de la actividad.
**Timeout:PgSleep**
Un proceso de backend llamó a la función pg\$1sleep y espera a que el tiempo de espera venza. Para obtener más información, consulte [Timeout:PgSleep](apg-waits.timeoutpgsleep.md).
**Timeout:RecoveryApplyDelay**
Un proceso está esperando para aplicar el registro de escritura anticipada (WAL) durante la recuperación debido a una configuración de retraso.
**Timeout:RecoveryRetrieveRetryInterval**
Un proceso está esperando durante la recuperación cuando los datos del registro de escritura anticipada (WAL) no están disponibles desde ningún origen (pg\$1wal, archivo o transmisión).
**Timeout:VacuumDelay**
Un proceso está esperando en un punto de retraso de vacuum basado en costos.
Para una lista completa de eventos de espera de PostgreSQL, consulte la [tabla de eventos de espera de PostgreSQL](https://www.postgresql.org/docs/current/monitoring-stats.html#WAIT-EVENT-TABLE) en la documentación de PostgreSQL.