# 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
```