# Aurora PostgreSQL 함수 참조
다음에서 Aurora PostgreSQL 호환 버전 DB 엔진을 실행하는 Aurora DB 클러스터에 사용할 수 있는 Aurora PostgreSQL 함수 목록을 찾을 수 있습니다. 이러한 Aurora PostgreSQL 함수는 표준 PostgreSQL 함수에 추가됩니다. 표준 PostgreSQL 함수에 대한 자세한 내용은 [PostgreSQL—함수와 연산자](https://www.postgresql.org/docs/current/functions.html)를 찹조하세요.
## 개요
Aurora PostgreSQL을 실행하는 Amazon RDS DB 인스턴스에 다음 함수를 사용할 수 있습니다.
+ [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
연결된 DB 인스턴스의 이름을 보고합니다.
## 구문
```
aurora_db_instance_identifier()
```
## 인수
없음
## 반환 타입
VARCHAR 문자열
## 사용 노트
이 함수는 데이터베이스 클라이언트 또는 애플리케이션 연결을 위한 Aurora PostgreSQL-Compatible Edition 클러스터의 DB 인스턴스 이름을 표시합니다.
이 함수는 Aurora PostgreSQL 버전 13.7, 12.11, 11.16, 10.21 및 기타 모든 이후 버전의 릴리스부터 사용할 수 있습니다.
## 예시
다음 예제에서는 `aurora_db_instance_identifier` 함수 호출의 결과를 보여줍니다.
```
=> SELECT aurora_db_instance_identifier();
aurora_db_instance_identifier
-------------------------------
test-my-instance-name
```
이 함수의 결과를 `aurora_replica_status` 함수와 결합하여 연결을 위한 DB 인스턴스에 대한 세부 정보를 얻을 수 있습니다. [aurora\$1replica\$1status](aurora_replica_status.md) 단독으로는 사용 중인 DB 인스턴스가 표시되지 않습니다. 다음 예에서는 이 작업을 수행하는 방법을 보여줍니다.
```
=> SELECT *
FROM aurora_replica_status() rt,
aurora_db_instance_identifier() di
WHERE rt.server_id = di;
-[ RECORD 1 ]----------------------+-----------------------
server_id | test-my-instance-name
session_id | MASTER_SESSION_ID
durable_lsn | 88492069
highest_lsn_rcvd |
current_read_lsn |
cur_replay_latency_in_usec |
active_txns |
is_current | t
last_transport_error | 0
last_error_timestamp |
last_update_timestamp | 2022-06-03 11:18:25+00
feedback_xmin |
feedback_epoch |
replica_lag_in_msec |
log_stream_speed_in_kib_per_second | 0
log_buffer_sequence_number | 0
oldest_read_view_trx_id |
oldest_read_view_lsn |
pending_read_ios | 819
```
# aurora\$1ccm\$1status
클러스터 캐시 관리자의 상태를 표시합니다.
## 구문
```
aurora_ccm_status()
```
## 인수
없음.
## 반환 타입
다음 열이 있는 SETOF 레코드:
+ `buffers_sent_last_minute` - 지난 1분 동안 지정된 리더로 전송된 버퍼 수입니다.
+ `buffers_found_last_minute` - 지난 1분 동안 식별된 자주 액세스된 버퍼 수입니다.
+ `buffers_sent_last_scan` – 버퍼 캐시의 마지막 전체 검색 중에 지정된 리더로 전송된 버퍼 수입니다.
+ `buffers_found_last_scan` – 버퍼 캐시의 마지막 전체 검색 중에 자주 액세스된 버퍼 수입니다. 지정된 리더에 이미 캐시된 버퍼는 전송되지 않습니다.
+ `buffers_sent_current_scan` - 현재 스캔 중에 전송된 버퍼 수입니다.
+ `buffers_found_current_scan` - 현재 스캔에서 식별된 자주 액세스된 버퍼 수입니다.
+ `current_scan_progress` - 현재 스캔 중에 지금까지 방문한 버퍼 수입니다.
## 사용 노트
이 함수를 사용하여 클러스터 캐시 관리(CCM) 기능을 확인하고 모니터링할 수 있습니다. 이 함수는 Aurora PostgreSQL DB 클러스터에서 CCM이 활성화된 경우에만 작동합니다. 이 함수를 사용하려면 Aurora PostgreSQL DB 클러스터의 Write DB 인스턴스에 연결합니다.
클러스터의 Custom DB 클러스터 파라미터 그룹에서 `apg_ccm_enabled`를 1로 설정하여 Aurora PostgreSQL DB 클러스터에 대한 CCM을 켭니다. 자세한 방법은 [클러스터 캐시 관리 구성](AuroraPostgreSQL.cluster-cache-mgmt.md#AuroraPostgreSQL.cluster-cache-mgmt.Configure)을 참조하세요.
클러스터에 Aurora Reader 인스턴스가 다음과 같이 구성된 경우 Aurora PostgreSQL DB 클러스터에서 클러스터 캐시 관리가 활성화됩니다.
+ Aurora Reader 인스턴스는 클러스터의 Writer 인스턴스와 동일한 DB 인스턴스 클래스 유형 및 크기를 사용합니다.
+ Aurora Reader 인스턴스는 클러스터의 Tier-0으로 구성됩니다. 클러스터에 둘 이상의 Reader가 있는 경우 이게 유일한 Tier-0 Reader입니다.
둘 이상의 Reader를 Tier-0으로 설정하면 CCM이 사용 중지됩니다. CCM이 사용 중지된 경우 이 함수를 호출하면 다음과 같은 오류 메시지가 반환됩니다.
```
ERROR: Cluster Cache Manager is disabled
```
또한 PostgreSQL pg\$1buffercache 확장 프로그램을 사용하여 버퍼 캐시를 분석할 수 있습니다. 자세한 내용은 PostgreSQL 설명서의 [pg\$1buffercache](https://www.postgresql.org/docs/current/pgbuffercache.html)를 참조하세요.
자세한 내용은 [Introduction to Aurora PostgreSQL cluster cache management](https://aws.amazon.com/blogs/database/introduction-to-aurora-postgresql-cluster-cache-management/)(Aurora PostgreSQL 클러스터 캐시 관리 소개)를 참조하세요.
## 예시
다음 예제에서는 `aurora_ccm_status` 함수 호출의 결과를 보여줍니다. 이 첫 번째 예제에서는 CCM 통계를 보여줍니다.
```
=> SELECT * FROM aurora_ccm_status();
buffers_sent_last_minute | buffers_found_last_minute | buffers_sent_last_scan | buffers_found_last_scan | buffers_sent_current_scan | buffers_found_current_scan | current_scan_progress
--------------------------+---------------------------+------------------------+-------------------------+---------------------------+----------------------------+-----------------------
2242000 | 2242003 | 17920442 | 17923410 | 14098000 | 14100964 | 15877443
```
보다 자세한 내용을 보려면 다음과 같이 확장된 디스플레이를 사용하면 됩니다.
```
\x
Expanded display is on.
SELECT * FROM aurora_ccm_status();
[ RECORD 1 ]-----------------------+---------
buffers_sent_last_minute | 2242000
buffers_found_last_minute | 2242003
buffers_sent_last_scan | 17920442
buffers_found_last_scan | 17923410
buffers_sent_current_scan | 14098000
buffers_found_current_scan | 14100964
current_scan_progress | 15877443
```
이 예제에서는 웜 비율과 웜 백분율을 확인하는 방법을 보여줍니다.
```
=> SELECT buffers_sent_last_minute * 8/60 AS warm_rate_kbps,
100 * (1.0-buffers_sent_last_scan/buffers_found_last_scan) AS warm_percent
FROM aurora_ccm_status ();
warm_rate_kbps | warm_percent
----------------+--------------
16523 | 100.0
```
# aurora\$1global\$1db\$1instance\$1status
Aurora 전역 DB 클러스터의 복제본을 포함하여 모든 Aurora 인스턴스의 상태를 표시합니다.
## 구문
```
aurora_global_db_instance_status()
```
## 인수
없음
## 반환 타입
다음 열이 있는 SETOF 레코드:
+ `server_id` - DB 인스턴스의 식별자입니다.
+ `session_id` - 현재 세션에 대한 고유한 식별자입니다. `MASTER_SESSION_ID`의 값은 Writer(프라이머리) DB 인스턴스를 식별합니다.
+ `aws_region` - 이 전역 DB 인스턴스가 실행되는 AWS 리전입니다. 리전 목록은 [리전 가용성](Concepts.RegionsAndAvailabilityZones.md#Aurora.Overview.Availability) 섹션을 참조하세요.
+ `durable_lsn` - 스토리지에서 내구성이 뛰어난 로그 시퀀스 번호(LSN)입니다. LSN(로그 시퀀스 번호)은 데이터베이스 트랜잭션 로그의 레코드를 식별하는 고유한 순차적 번호입니다. LSN은 더 큰 LSN이 더 이후의 트랜잭션을 나타내도록 정렬됩니다.
+ `highest_lsn_rcvd` - 라이터 DB 인스턴스에서 DB 인스턴스가 수신한 가장 높은 LSN입니다.
+ `feedback_epoch` – DB 인스턴스가 상시 대기 방식 정보를 생성할 때 사용하는 epoch입니다. *상시 대기 방식*은 프라이머리 DB가 복구 또는 대기 모드에 있는 동안 연결 및 쿼리를 지원하는 DB 인스턴스입니다. 상시 대기 방식 정보에는 epoch(시점)와 상시 대기 방식으로 사용되는 DB 인스턴스에 대한 기타 세부 정보가 포함됩니다. 자세한 내용은 PostgreSQL 설명서의 [핫 스탠바이](https://www.postgresql.org/docs/current/hot-standby.html)를 참조하세요.
+ `feedback_xmin` - DB 인스턴스가 사용하는 최소(가장 오래된) 활성 트랜잭션 ID입니다.
+ `oldest_read_view_lsn` – DB 인스턴스가 스토리지에서 읽는 데 사용하는 가장 오래된 LSN입니다.
+ `visibility_lag_in_msec` - 이 DB 인스턴스가 라이터 DB 인스턴스보다 지연된 시간(밀리초)입니다.
## 사용 노트
이 함수는 Aurora DB 클러스터에 대한 복제 통계를 보여줍니다. 클러스터의 각 Aurora PostgreSQL DB 인스턴스에 대해 이 함수는 글로벌 데이터베이스 구성에서 크로스 리전 복제본을 포함하는 데이터 행을 표시합니다.
Aurora PostgreSQL DB 클러스터의 인스턴스나 Aurora PostgreSQL 전역 데이터베이스의 인스턴스에서 이 함수를 실행할 수 있습니다. 이 함수는 모든 복제본 인스턴스의 지연에 대한 세부 정보를 반환합니다.
이 함수(`aurora_global_db_instance_status`)를 사용하거나 `aurora_global_db_status`를 사용하여 지연 모니터링에 대해 자세히 알아보려면 [Aurora PostgreSQL 기반 글로벌 데이터베이스 모니터링](aurora-global-database-monitoring.md#aurora-global-database-monitoring.postgres) 섹션을 참조하세요.
Aurora 전역 데이터베이스에 대한 자세한 내용은 [Amazon Aurora Global Database 개요](aurora-global-database.md#aurora-global-database-overview) 섹션을 참조하세요.
Aurora 전역 데이터베이스를 시작하려면 [Amazon Aurora Global Database 시작하기](aurora-global-database-getting-started.md) 섹션 또는 [Amazon Aurora FAQ](https://aws.amazon.com/rds/aurora/faqs/)를 참조하세요.
## 예시
이 예시에서는 크로스 리전 인스턴스 통계를 보여줍니다.
```
=> SELECT *
FROM aurora_global_db_instance_status();
server_id | session_id | aws_region | durable_lsn | highest_lsn_rcvd | feedback_epoch | feedback_xmin | oldest_read_view_lsn | visibility_lag_in_msec
------------------------------------------+--------------------------------------+--------------+-------------+------------------+----------------+---------------+----------------------+------------------------
db-119-001-instance-01 | MASTER_SESSION_ID | eu-west-1 | 2534560273 | [NULL] | [NULL] | [NULL] | [NULL] | [NULL]
db-119-001-instance-02 | 4ecff34d-d57c-409c-ba28-278b31d6fc40 | eu-west-1 | 2534560266 | 2534560273 | 0 | 19669196 | 2534560266 | 6
db-119-001-instance-03 | 3e8a20fc-be86-43d5-95e5-bdf19d27ad6b | eu-west-1 | 2534560266 | 2534560273 | 0 | 19669196 | 2534560266 | 6
db-119-001-instance-04 | fc1b0023-e8b4-4361-bede-2a7e926cead6 | eu-west-1 | 2534560266 | 2534560273 | 0 | 19669196 | 2534560254 | 23
db-119-001-instance-05 | 30319b74-3f08-4e13-9728-e02aa1aa8649 | eu-west-1 | 2534560266 | 2534560273 | 0 | 19669196 | 2534560254 | 23
db-119-001-global-instance-1 | a331ffbb-d982-49ba-8973-527c96329c60 | eu-central-1 | 2534560254 | 2534560266 | 0 | 19669196 | 2534560247 | 996
db-119-001-global-instance-1 | e0955367-7082-43c4-b4db-70674064a9da | eu-west-2 | 2534560254 | 2534560266 | 0 | 19669196 | 2534560247 | 14
db-119-001-global-instance-1-eu-west-2a | 1248dc12-d3a4-46f5-a9e2-85850491a897 | eu-west-2 | 2534560254 | 2534560266 | 0 | 19669196 | 2534560247 | 0
```
이 예제에서는 밀리초 단위로 전역 복제본 지연을 확인하는 방법을 보여줍니다.
```
=> SELECT CASE
WHEN 'MASTER_SESSION_ID' = session_id THEN 'Primary'
ELSE 'Secondary'
END AS global_role,
aws_region,
server_id,
visibility_lag_in_msec
FROM aurora_global_db_instance_status()
ORDER BY 1, 2, 3;
global_role | aws_region | server_id | visibility_lag_in_msec
-------------+--------------+-----------------------------------------+------------------------
Primary | eu-west-1 | db-119-001-instance-01 | [NULL]
Secondary | eu-central-1 | db-119-001-global-instance-1 | 13
Secondary | eu-west-1 | db-119-001-instance-02 | 10
Secondary | eu-west-1 | db-119-001-instance-03 | 9
Secondary | eu-west-1 | db-119-001-instance-04 | 2
Secondary | eu-west-1 | db-119-001-instance-05 | 18
Secondary | eu-west-2 | db-119-001-global-instance-1 | 14
Secondary | eu-west-2 | db-119-001-global-instance-1-eu-west-2a | 13
```
이 예제에서는 전역 데이터베이스 구성에서 AWS 리전당 최소, 최대 및 평균 지연을 확인하는 방법을 보여줍니다.
```
=> SELECT 'Secondary' global_role,
aws_region,
min(visibility_lag_in_msec) min_lag_in_msec,
max(visibility_lag_in_msec) max_lag_in_msec,
round(avg(visibility_lag_in_msec),0) avg_lag_in_msec
FROM aurora_global_db_instance_status()
WHERE aws_region NOT IN (SELECT aws_region
FROM aurora_global_db_instance_status()
WHERE session_id='MASTER_SESSION_ID')
GROUP BY aws_region
UNION ALL
SELECT 'Primary' global_role,
aws_region,
NULL,
NULL,
NULL
FROM aurora_global_db_instance_status()
WHERE session_id='MASTER_SESSION_ID'
ORDER BY 1, 5;
global_role | aws_region | min_lag_in_msec | max_lag_in_msec | avg_lag_in_msec
------------+--------------+-----------------+-----------------+-----------------
Primary | eu-west-1 | [NULL] | [NULL] | [NULL]
Secondary | eu-central-1 | 133 | 133 | 133
Secondary | eu-west-2 | 0 | 495 | 248
```
# aurora\$1global\$1db\$1status
Aurora Global Database 지연의 다양한 측면, 특히 기본 Aurora 스토리지의 지연(내구성 지연) 및 Recovery Point Objective(RPO) 간의 지연에 대한 정보를 표시합니다.
## 구문
```
aurora_global_db_status()
```
## 인수
없음.
## 반환 타입
다음 열이 있는 SETOF 레코드:
+ `aws_region` - 이 DB 클러스터가 있는 AWS 리전입니다. 엔진별 AWS 리전의 전체 목록을 보려면 [리전 및 가용 영역](Concepts.RegionsAndAvailabilityZones.md) 섹션을 참조하세요.
+ `highest_lsn_written` - 이 DB 클러스터에 현재 존재하는 가장 높은 로그 시퀀스 번호(LSN)입니다. LSN(로그 시퀀스 번호)은 데이터베이스 트랜잭션 로그의 레코드를 식별하는 고유한 순차적 번호입니다. LSN은 더 큰 LSN이 더 이후의 트랜잭션을 나타내도록 정렬됩니다.
+ `durability_lag_in_msec` - 보조 DB 클러스터의 `highest_lsn_written`과 기본 DB 클러스터의 `highest_lsn_written` 간 타임스탬프 값 차이입니다. -1 값은 Aurora Global Database의 기본 DB 클러스터를 식별합니다.
+ `rpo_lag_in_msec` - Recovery Point Objective(RPO) 지연입니다. RPO 지연은 Aurora Global Databse의 기본 DB 클러스터에 저장된 후 가장 최근의 사용자 트랜잭션 COMMIT 보조 DB 클러스터에 저장하는 데 걸리는 시간입니다. -1 값은 기본 DB 클러스터를 나타냅니다. 따라서 지연은 관련이 없습니다.
간단히 말해서 이 지표는 Aurora Global Databse의 각 Aurora PostgreSQL DB 클러스터에 대한 복구 시점 목표, 즉 중단 시 손실될 수 있는 데이터의 양을 계산합니다. 지연과 마찬가지로 RPO는 시간 단위로 측정됩니다.
+ `last_lag_calculation_time` - `durability_lag_in_msec` 및 `rpo_lag_in_msec`에 대한 값이 마지막으로 계산된 시점을 지정하는 타임스탬프입니다. 시간 값(예: `1970-01-01 00:00:00+00`)은 이것이 기본 DB 클러스터임을 의미합니다.
+ `feedback_epoch` – 보조 DB 클러스터가 상시 대기 방식 정보를 생성할 때 사용하는 epoch입니다. *상시 대기 방식*은 프라이머리 DB가 복구 또는 대기 모드에 있는 동안 연결 및 쿼리를 지원하는 DB 인스턴스입니다. 상시 대기 방식 정보에는 epoch(시점)와 상시 대기 방식으로 사용되는 DB 인스턴스에 대한 기타 세부 정보가 포함됩니다. 자세한 내용은 PostgreSQL 설명서의 [핫 스탠바이](https://www.postgresql.org/docs/current/hot-standby.html)를 참조하세요.
+ `feedback_xmin` – 보조 DB 클러스터가 사용하는 최소(가장 오래된) 활성 트랜잭션 ID입니다.
## 사용 노트
현재 사용 가능한 모든 Aurora PostgreSQL 버전에서 이 함수를 지원합니다. 이 함수는 Aurora 전역 데이터베이스에 대한 복제 통계를 보여줍니다. Aurora PostgreSQL 전역 데이터베이스의 각 DB 클러스터에 대해 하나의 행을 표시합니다. Aurora PostgreSQL 전역 데이터베이스의 인스턴스에서 이 함수를 실행할 수 있습니다.
표시되는 데이터 지연인 Aurora 전역 데이터베이스 복제 지연을 평가하려면[aurora\$1global\$1db\$1instance\$1status](aurora_global_db_instance_status.md) 섹션을 참조하세요.
`aurora_global_db_status` 및 `aurora_global_db_instance_status`를 사용하여 Aurora 전역 데이터베이스 지연을 모니터링하는 방법에 대해 자세히 알아보려면 [Aurora PostgreSQL 기반 글로벌 데이터베이스 모니터링](aurora-global-database-monitoring.md#aurora-global-database-monitoring.postgres) 섹션을 참조하세요. Aurora 전역 데이터베이스에 대한 자세한 내용은 [Amazon Aurora Global Database 개요](aurora-global-database.md#aurora-global-database-overview) 섹션을 참조하세요.
## 예시
이 예제에서는 교차 리전 스토리지 통계를 표시하는 방법을 보여줍니다.
```
=> SELECT CASE
WHEN '-1' = durability_lag_in_msec THEN 'Primary'
ELSE 'Secondary'
END AS global_role,
*
FROM aurora_global_db_status();
global_role | aws_region | highest_lsn_written | durability_lag_in_msec | rpo_lag_in_msec | last_lag_calculation_time | feedback_epoch | feedback_xmin
-------------+------------+---------------------+------------------------+-----------------+----------------------------+----------------+---------------
Primary | eu-west-1 | 131031557 | -1 | -1 | 1970-01-01 00:00:00+00 | 0 | 0
Secondary | eu-west-2 | 131031554 | 410 | 0 | 2021-06-01 18:59:36.124+00 | 0 | 12640
Secondary | eu-west-3 | 131031554 | 410 | 0 | 2021-06-01 18:59:36.124+00 | 0 | 12640
```
# aurora\$1list\$1builtins
사용 가능한 모든 Aurora PostgreSQL 내장 함수를 간략한 설명 및 함수 세부 정보와 함께 나열합니다.
## 구문
```
aurora_list_builtins()
```
## 인수
없음
## 반환 타입
SETOF 레코드
## 예시
다음 예제에서는 `aurora_list_builtins` 함수 호출의 결과를 보여줍니다.
```
=> SELECT *
FROM aurora_list_builtins();
Name | Result data type | Argument data types | Type | Volatility | Parallel | Security | Description
-----------------------------------+------------------+----------------------------------------------------------+------+------------+------------+----------+---------------------------------------------------------------------
aurora_version | text | | func | stable | safe | invoker | Amazon Aurora PostgreSQL-Compatible Edition version string
aurora_stat_wait_type | SETOF record | OUT type_id smallint, OUT type_name text | func | volatile | restricted | invoker | Lists all supported wait types
aurora_stat_wait_event | SETOF record | OUT type_id smallint, OUT event_id integer, OUT event_na.| func | volatile | restricted | invoker | Lists all supported wait events
| |.me text | | | | |
aurora_list_builtins | SETOF record | OUT "Name" text, OUT "Result data type" text, OUT "Argum.| func | stable | safe | invoker | Lists all Aurora built-in functions
| |.ent data types" text, OUT "Type" text, OUT "Volatility" .| | | | |
| |.text, OUT "Parallel" text, OUT "Security" text, OUT "Des.| | | | |
| |.cription" text | | | | |
.
.
.
aurora_stat_file | SETOF record | OUT filename text, OUT allocated_bytes bigint, OUT used_.| func | stable | safe | invoker | Lists all files present in Aurora storage
| |.bytes bigint | | | | |
aurora_stat_get_db_commit_latency | bigint | oid | func | stable | restricted | invoker | Per DB commit latency in microsecs
```
# aurora\$1replica\$1status
모든 Aurora PostgreSQL 리더 노드의 상태를 표시합니다.
## 구문
```
aurora_replica_status()
```
## 인수
없음
## 반환 타입
다음 열이 있는 SETOF 레코드:
+ `server_id` - DB 인스턴스 ID(식별자)
+ `session_id` - 현재 세션의 고유 식별자로, 다음과 같이 기본 인스턴스 및 리더 인스턴스에 대해 반환됩니다.
+ 기본 인스턴스의 경우`session_id`는 항상 ``MASTER_SESSION_ID’`입니다.
+ 리더 인스턴스의 경우`session_id`는 항상 리더 인스턴스의 `UUID`(Universally Unique Identifier)입니다.
+ `durable_lsn` - 스토리지에 저장된 LSN(로그 시퀀스 번호)입니다.
+ 기본 볼륨의 경우 현재 적용 중인 기본 볼륨 내구성 LSN(VDL)입니다.
+ 보조 볼륨의 경우 보조 볼륨이 성공적으로 적용된 기본 볼륨의 VDL입니다.
**참고**
LSN(로그 시퀀스 번호)은 데이터베이스 트랜잭션 로그의 레코드를 식별하는 고유한 순차적 번호입니다. LSN은 더 큰 LSN이 더 이후의 시퀀스에서 발생한 트랜잭션을 나타내도록 정렬됩니다.
+ `highest_lsn_rcvd` - 라이터 DB 인스턴스에서 DB 인스턴스가 수신한 가장 높은(최신) LSN입니다.
+ `current_read_lsn` - 모든 리더에 적용된 최신 스냅샷의 LSN입니다.
+ `cur_replay_latency_in_usec` - 보조 볼륨에서 로그를 재생하는 데 걸리는 시간(마이크로초)입니다.
+ `active_txns` - 현재 활성 DML 트랜잭션의 수입니다.
+ `is_current` - 사용되지 않습니다.
+ `last_transport_error` - 마지막 복제 오류 코드입니다.
+ `last_error_timestamp` - 마지막 복제 오류의 타임스탬프입니다.
+ `last_update_timestamp` - 복제본 상태에 대한 마지막 업데이트의 타임스탬프입니다. Aurora PostgreSQL 13.9부터는 연결된 DB 인스턴스의 `last_update_timestamp` 값이 `NULL`로 설정됩니다.
+ `feedback_xmin` - 복제본의 상시 대기 feedback\$1xmin입니다. DB 인스턴스가 사용하는 최소(가장 오래된) 활성 트랜잭션 ID입니다.
+ `feedback_epoch` – DB 인스턴스가 상시 대기 정보를 생성할 때 사용하는 Epoch입니다.
+ `replica_lag_in_msec` - 리더 인스턴스가 라이터 인스턴스보다 지연되는 시간(밀리초)입니다.
+ `log_stream_speed_in_kib_per_second` - 로그 스트림 처리량(초당 KB)입니다.
+ `log_buffer_sequence_number` - 로그 버퍼 시퀀스 번호입니다.
+ `oldest_read_view_trx_id` - 사용되지 않습니다.
+ `oldest_read_view_lsn` – DB 인스턴스가 스토리지에서 읽는 데 사용하는 가장 오래된 LSN입니다.
+ `pending_read_ios` - 복제본에서 여전히 보류 중인 미해결 페이지 읽기입니다.
+ `read_ios` - 복제본의 총 페이지 읽기 횟수입니다.
+ `iops` - 사용되지 않습니다.
+ `cpu` - 클러스터의 각 노드에 대한 Aurora 스토리지 대몬의 CPU 사용량입니다. 인스턴스별 CPU 사용량에 대한 자세한 내용은 [Amazon Aurora에 대한 인스턴스 수준 지표](Aurora.AuroraMonitoring.Metrics.md#Aurora.AuroraMySQL.Monitoring.Metrics.instances) 단원을 참조하세요.
## 사용 노트
현재 사용 가능한 모든 Aurora PostgreSQL 버전에서 이 함수를 지원합니다. `aurora_replica_status` 함수는 Aurora PostgreSQL DB 클러스터의 복제본 상태 관리자에서 값을 반환합니다. 이 함수를 사용하면 Aurora DB 클러스터의 모든 DB 인스턴스에 대한 지표를 포함하여 Aurora PostgreSQL DB 클러스터의 복제 상태에 대한 정보를 얻을 수 있습니다. 예를 들어, 다음을 수행할 수 있습니다.
+ **Aurora PostgreSQL DB 클러스터의 인스턴스 유형(라이터, 리더)에 대한 정보 가져오기** - 다음 열의 값을 확인하여 이 정보를 얻을 수 있습니다.
+ `server_id` - 인스턴스를 생성할 때 지정한 인스턴스의 이름을 포함합니다. 기본(라이터) 인스턴스 등 일부 경우에는 일반적으로 Aurora PostgreSQL DB 클러스터에 대해 생성한 이름에 *-instance-1*을 추가하여 이름이 생성됩니다.
+ `session_id` - `session_id` 필드는 인스턴스가 리더인지 라이터인지를 나타냅니다. 라이터 인스턴스의 경우 `session_id`는 항상 `"MASTER_SESSION_ID"`로 설정됩니다. 리더 인스턴스의 경우,`session_id`는 특정 리더의 `UUID`로 설정됩니다.
+ **복제본 지연과 같은 일반적인 복제 문제 진단** - 복제본 지연은 리더 인스턴스의 페이지 캐시가 라이터 인스턴스의 페이지 캐시보다 뒤처지는 시간(밀리초)입니다. 이 지연은 [Amazon Aurora를 사용한 복제](Aurora.Replication.md)에 설명된 대로 Aurora 클러스터에서 비동기 복제를 사용하기 때문에 발생합니다. 이 함수가 반환한 결과의 `replica_lag_in_msec` 열에 표시됩니다. 대기 서버의 복구 충돌로 인해 쿼리가 취소되는 경우에도 지연이 발생할 수 있습니다. `pg_stat_database_conflicts()`를 통해 이러한 충돌로 인해 복제본 지연이 발생하는지 확인할 수 있습니다. 자세한 내용은 *PostgreSQL 설명서*에서 [통계 수집기](https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-DATABASE-CONFLICTS-VIEW)를 참조하세요. 고가용성 및 복제에 대한 자세한 내용은 [Amazon Aurora FAQ](https://aws.amazon.com/rds/aurora/faqs/#High_Availability_and_Replication) 섹션을 참조하세요.
Amazon CloudWatch는 시간 경과에 따른 `replica_lag_in_msec` 결과를 `AuroraReplicaLag` 지표로 저장합니다. Aurora에 CloudWatch 지표를 사용하는 방법에 관한 자세한 내용은 [Amazon CloudWatch로 Amazon Aurora 지표 모니터링](monitoring-cloudwatch.md) 단원을 참조하세요.
Aurora 읽기 전용 복제본 및 재시작 문제 해결에 대한 자세한 내용은 [AWS Support 센터](https://console.aws.amazon.com/support/home#/)의 [Amazon Aurora 읽기 전용 복제본이 뒤처지고 다시 시작되는 이유는 무엇입니까?](https://aws.amazon.com/premiumsupport/knowledge-center/aurora-read-replica-restart/) 섹션을 참조하세요.
## 예시
다음 예제에서는 Aurora PostgreSQL DB 클러스터에 있는 모든 인스턴스의 복제 상태를 가져오는 방법을 보여줍니다.
```
=> SELECT *
FROM aurora_replica_status();
```
다음 예제는 `docs-lab-apg-main` Aurora PostgreSQL DB 클러스터의 라이터 인스턴스를 보여줍니다.
```
=> SELECT server_id,
CASE
WHEN 'MASTER_SESSION_ID' = session_id THEN 'writer'
ELSE 'reader'
END AS instance_role
FROM aurora_replica_status()
WHERE session_id = 'MASTER_SESSION_ID';
server_id | instance_role
------------------------+---------------
db-119-001-instance-01 | writer
```
다음 예제에서는 클러스터의 모든 리더 인스턴스를 나열합니다.
```
=> SELECT server_id,
CASE
WHEN 'MASTER_SESSION_ID' = session_id THEN 'writer'
ELSE 'reader'
END AS instance_role
FROM aurora_replica_status()
WHERE session_id <> 'MASTER_SESSION_ID';
server_id | instance_role
------------------------+---------------
db-119-001-instance-02 | reader
db-119-001-instance-03 | reader
db-119-001-instance-04 | reader
db-119-001-instance-05 | reader
(4 rows)
```
다음 예제에서는 모든 인스턴스, 각 인스턴스가 라이터보다 지연되는 시간 및 마지막 업데이트 이후의 기간을 나열합니다.
```
=> SELECT server_id,
CASE
WHEN 'MASTER_SESSION_ID' = session_id THEN 'writer'
ELSE 'reader'
END AS instance_role,
replica_lag_in_msec AS replica_lag_ms,
round(extract (epoch FROM (SELECT age(clock_timestamp(), last_update_timestamp))) * 1000) AS last_update_age_ms
FROM aurora_replica_status()
ORDER BY replica_lag_in_msec NULLS FIRST;
server_id | instance_role | replica_lag_ms | last_update_age_ms
------------------------+---------------+----------------+--------------------
db-124-001-instance-03 | writer | [NULL] | 1756
db-124-001-instance-01 | reader | 13 | 1756
db-124-001-instance-02 | reader | 13 | 1756
(3 rows)
```
# aurora\$1stat\$1activity
서버 프로세스당 하나의 행을 반환하며 해당 프로세스의 현재 활동과 관련된 정보를 표시합니다.
## 구문
```
aurora_stat_activity();
```
## 인수
없음
## 반환 타입
서버 프로세스당 하나의 행을 반환합니다. `pg_stat_activity` 열 외에도 다음 필드가 추가됩니다.
+ planid – 계획 식별자
## 사용 노트
현재 쿼리 실행 계획을 보여주는 추가 `plan_id` 열과 함께 동일한 열을 반환하기 위한 `pg_stat_activity`의 보조 뷰입니다.
뷰에서 plan\$1id를 반환하려면 `aurora_compute_plan_id`가 활성화되어야 합니다.
이 함수는 Aurora PostgreSQL 버전 14.10 및 15.5 이상 모든 버전의 릴리스부터 사용할 수 있습니다.
## 예시
아래 예제 쿼리는 query\$1id 및 plan\$1id를 기준으로 상위 부하를 집계합니다.
```
db1=# select count(*), query_id, plan_id
db1-# from aurora_stat_activity() where state = 'active'
db1-# and pid <> pg_backend_pid()
db1-# group by query_id, plan_id
db1-# order by 1 desc;
count | query_id | plan_id
-------+----------------------+-------------
11 | -5471422286312252535 | -2054628807
3 | -6907107586630739258 | -815866029
1 | 5213711845501580017 | 300482084
(3 rows)
```
query\$1id에 사용되는 계획이 변경되면 aurora\$1stat\$1activity에서 새 plan\$1id를 보고합니다.
```
count | query_id | plan_id
-------+----------------------+-------------
10 | -5471422286312252535 | 1602979607
1 | -6907107586630739258 | -1809935983
1 | -2446282393000597155 | -207532066
(3 rows)
```
# aurora\$1stat\$1backend\$1waits
특정 백엔드 프로세스의 대기 활동에 대한 통계를 표시합니다.
## 구문
```
aurora_stat_backend_waits(pid)
```
## 인수
`pid` - 백엔드 프로세스의 ID입니다. `pg_stat_activity` 보기를 사용하여 프로세스 ID를 얻을 수 있습니다.
## 반환 타입
다음 열이 있는 SETOF 레코드:
+ `type_id` - 몇 가지 예제에 이름을 지정하기 위해 경량 잠금(`LWLock`)용 `1`, 잠금용 `3`, 클라이언트 세션용 `6`과 같이 대기 이벤트 유형을 나타내는 숫자입니다. 이 함수의 결과를 [예시](#aurora_stat_backend_waits-examples)에서 볼 수 있듯 `aurora_stat_wait_type`의 열과 결합하면 이러한 값이 의미 있게 됩니다.
+ `event_id` - 대기 이벤트에 대한 식별 번호입니다. 이 값을 `aurora_stat_wait_event`의 열과 결합하여 유의미한 이벤트 이름을 획득합니다.
+ `waits` - 지정한 프로세스 ID에 대해 누적된 대기 시간입니다.
+ `wait_time` - 대기 시간(밀리초)입니다.
## 사용 노트
이 함수를 사용하여 연결이 개방된 이후 발생한 특정 백엔드(세션) 대기 이벤트를 분석할 수 있습니다. 대기 이벤트 이름 및 유형에 대한 보다 의미 있는 정보를 얻으려면 예제에 나와 있듯 JOIN을 사용하여 함수 `aurora_stat_wait_type` 및 `aurora_stat_wait_event`를 결합하면 됩니다.
## 예시
이 예제에서는 백엔드 프로세스 ID 3027에 대한 모든 대기, 유형 및 이벤트 이름을 보여줍니다.
```
=> SELECT type_name, event_name, waits, wait_time
FROM aurora_stat_backend_waits(3027)
NATURAL JOIN aurora_stat_wait_type()
NATURAL JOIN aurora_stat_wait_event();
type_name | event_name | waits | wait_time
-----------+------------------------+-------+------------
LWLock | ProcArrayLock | 3 | 27
LWLock | wal_insert | 423 | 16336
LWLock | buffer_content | 11840 | 1033634
LWLock | lock_manager | 23821 | 5664506
Lock | tuple | 10258 | 152280165
Lock | transactionid | 78340 | 1239808783
Client | ClientRead | 34072 | 17616684
IO | ControlFileSyncUpdate | 2 | 0
IO | ControlFileWriteUpdate | 4 | 32
IO | RelationMapRead | 2 | 795
IO | WALWrite | 36666 | 98623
IO | XactSync | 4867 | 7331963
```
이 예제에서는 모든 활성 세션(`pg_stat_activity state <> 'idle'`)에 대한 현재 및 누적 대기 유형과 대기 이벤트를 보여줍니다(단, 함수(`pid <> pg_backend_pid()`)를 호출하는 현재 세션은 제외).
```
=> SELECT a.pid,
a.usename,
a.app_name,
a.current_wait_type,
a.current_wait_event,
a.current_state,
wt.type_name AS wait_type,
we.event_name AS wait_event,
a.waits,
a.wait_time
FROM (SELECT pid,
usename,
left(application_name,16) AS app_name,
coalesce(wait_event_type,'CPU') AS current_wait_type,
coalesce(wait_event,'CPU') AS current_wait_event,
state AS current_state,
(aurora_stat_backend_waits(pid)).*
FROM pg_stat_activity
WHERE pid <> pg_backend_pid()
AND state <> 'idle') a
NATURAL JOIN aurora_stat_wait_type() wt
NATURAL JOIN aurora_stat_wait_event() we;
pid | usename | app_name | current_wait_type | current_wait_event | current_state | wait_type | wait_event | waits | wait_time
-------+----------+----------+-------------------+--------------------+---------------+-----------+------------------------+-------+-----------
30099 | postgres | pgbench | Lock | transactionid | active | LWLock | wal_insert | 1937 | 29975
30099 | postgres | pgbench | Lock | transactionid | active | LWLock | buffer_content | 22903 | 760498
30099 | postgres | pgbench | Lock | transactionid | active | LWLock | lock_manager | 10012 | 223207
30099 | postgres | pgbench | Lock | transactionid | active | Lock | tuple | 20315 | 63081529
.
.
.
30099 | postgres | pgbench | Lock | transactionid | active | IO | WALWrite | 93293 | 237440
30099 | postgres | pgbench | Lock | transactionid | active | IO | XactSync | 13010 | 19525143
30100 | postgres | pgbench | Lock | transactionid | active | LWLock | ProcArrayLock | 6 | 53
30100 | postgres | pgbench | Lock | transactionid | active | LWLock | wal_insert | 1913 | 25450
30100 | postgres | pgbench | Lock | transactionid | active | LWLock | buffer_content | 22874 | 778005
.
.
.
30109 | postgres | pgbench | IO | XactSync | active | LWLock | ProcArrayLock | 3 | 71
30109 | postgres | pgbench | IO | XactSync | active | LWLock | wal_insert | 1940 | 27741
30109 | postgres | pgbench | IO | XactSync | active | LWLock | buffer_content | 22962 | 776352
30109 | postgres | pgbench | IO | XactSync | active | LWLock | lock_manager | 9879 | 218826
30109 | postgres | pgbench | IO | XactSync | active | Lock | tuple | 20401 | 63581306
30109 | postgres | pgbench | IO | XactSync | active | Lock | transactionid | 50769 | 211645008
30109 | postgres | pgbench | IO | XactSync | active | Client | ClientRead | 89901 | 44192439
```
이 예제에서는 현재 세션(`pid <>pg_backend_pid()`)을 제외한 모든 활성 세션(`pg_stat_activity state <> 'idle'`)에 대한 현재 및 상위 3개의 누적 대기 유형과 대기 이벤트를 보여줍니다.
```
=> SELECT top3.*
FROM (SELECT a.pid,
a.usename,
a.app_name,
a.current_wait_type,
a.current_wait_event,
a.current_state,
wt.type_name AS wait_type,
we.event_name AS wait_event,
a.waits,
a.wait_time,
RANK() OVER (PARTITION BY pid ORDER BY a.wait_time DESC)
FROM (SELECT pid,
usename,
left(application_name,16) AS app_name,
coalesce(wait_event_type,'CPU') AS current_wait_type,
coalesce(wait_event,'CPU') AS current_wait_event,
state AS current_state,
(aurora_stat_backend_waits(pid)).*
FROM pg_stat_activity
WHERE pid <> pg_backend_pid()
AND state <> 'idle') a
NATURAL JOIN aurora_stat_wait_type() wt
NATURAL JOIN aurora_stat_wait_event() we) top3
WHERE RANK <=3;
pid | usename | app_name | current_wait_type | current_wait_event | current_state | wait_type | wait_event | waits | wait_time | rank
-------+----------+----------+-------------------+--------------------+---------------+-----------+-----------------+---------+------------+------
20567 | postgres | psql | CPU | CPU | active | LWLock | wal_insert | 25000 | 67512003 | 1
20567 | postgres | psql | CPU | CPU | active | IO | WALWrite | 3071758 | 1016961 | 2
20567 | postgres | psql | CPU | CPU | active | IO | BufFileWrite | 20750 | 184559 | 3
27743 | postgres | pgbench | Lock | transactionid | active | Lock | transactionid | 237350 | 1265580011 | 1
27743 | postgres | pgbench | Lock | transactionid | active | Lock | tuple | 93641 | 341472318 | 2
27743 | postgres | pgbench | Lock | transactionid | active | Client | ClientRead | 417556 | 204796837 | 3
.
.
.
27745 | postgres | pgbench | IO | XactSync | active | Lock | transactionid | 238068 | 1265816822 | 1
27745 | postgres | pgbench | IO | XactSync | active | Lock | tuple | 93210 | 338312247 | 2
27745 | postgres | pgbench | IO | XactSync | active | Client | ClientRead | 419157 | 207836533 | 3
27746 | postgres | pgbench | Lock | transactionid | active | Lock | transactionid | 237621 | 1264528811 | 1
27746 | postgres | pgbench | Lock | transactionid | active | Lock | tuple | 93563 | 339799310 | 2
27746 | postgres | pgbench | Lock | transactionid | active | Client | ClientRead | 417304 | 208372727 | 3
```
# aurora\$1stat\$1bgwriter
`aurora_stat_bgwriter`는 최적화된 읽기 캐시 쓰기에 대한 정보를 보여주는 통계 뷰입니다.
## 구문
```
aurora_stat_bgwriter()
```
## 인수
없음
## 반환 타입
모든 `pg_stat_bgwriter` 열과 다음과 같은 추가 열이 포함된 SETOF 레코드. `pg_stat_bgwriter` 열에 대한 자세한 내용은 [https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-BGWRITER-VIEW](https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-BGWRITER-VIEW) 섹션을 참조하세요.
`pg_stat_reset_shared("bgwriter")`을 사용하여 이 함수의 통계를 재설정할 수 있습니다.
+ `orcache_blks_written` - 기록된 최적화된 읽기 캐시 데이터 블록의 총 수입니다.
+ `orcache_blk_write_time` - `track_io_timing`이 활성화된 경우 최적화된 읽기 캐시에서 데이터를 쓰는 데 소요된 총 시간을 밀리초 단위로 추적합니다. 자세한 내용은 [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING)을 참조하세요.
## 사용 노트
이 함수는 다음 Aurora PostgreSQL 버전에서 사용할 수 있습니다.
+ 15.4 이상의 15 버전
+ 14.9 이상의 14 버전
## 예시
```
=> select * from aurora_stat_bgwriter();
-[ RECORD 1 ]-----------------+-----------
orcache_blks_written | 246522
orcache_blk_write_time | 339276.404
```
# aurora\$1stat\$1database
pg\$1stat\$1database의 모든 열을 포함하고 끝에 새 열을 추가합니다.
## 구문
```
aurora_stat_database()
```
## 인수
없음
## 반환 타입
모든 `pg_stat_database` 열과 다음과 같은 추가 열이 포함된 SETOF 레코드. `pg_stat_database` 열에 대한 자세한 내용은 [https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-DATABASE-VIEW](https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-DATABASE-VIEW) 섹션을 참조하세요.
+ `storage_blks_read` - 이 데이터베이스의 Aurora 스토리지에서 읽은 총 공유 블록 수입니다.
+ `orcache_blks_hit` - 이 데이터베이스의 최적화된 읽기 캐시 적중률의 총 수입니다.
+ `local_blks_read` - 이 데이터베이스에서 읽은 총 로컬 블록 수입니다.
+ `storage_blk_read_time` - `track_io_timing`이 활성화된 경우 Aurora 스토리지에서 데이터 파일 블록을 읽는 데 소요된 총 시간을 밀리초 단위로 추적합니다. 활성화되지 않은 경우 값은 0입니다. 자세한 내용은 [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING)을 참조하세요.
+ `local_blk_read_time` - `track_io_timing`이 활성화된 경우 로컬 데이터 파일 블록을 읽는 데 소요된 총 시간을 밀리초 단위로 추적합니다. 활성화되지 않은 경우 값은 0입니다. 자세한 내용은 [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING)을 참조하세요.
+ `orcache_blk_read_time` - `track_io_timing`이 활성화된 경우 최적화된 읽기 캐시에서 데이터 파일 블록을 읽는 데 소요된 총 시간을 밀리초 단위로 추적합니다. 활성화되지 않은 경우 값은 0입니다. 자세한 내용은 [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING)을 참조하세요.
**참고**
`blks_read`의 값은 `storage_blks_read`, `orcache_blks_hit`, `local_blks_read`의 합계입니다.
`blk_read_time`의 값은 `storage_blk_read_time`, `orcache_blk_read_time`, `local_blk_read_time`의 합계입니다.
## 사용 노트
이 함수는 다음 Aurora PostgreSQL 버전에서 사용할 수 있습니다.
+ 15.4 이상의 15 버전
+ 14.9 이상의 14 버전
## 예시
다음 예는 모든 `pg_stat_database` 열을 포함하고 끝에 새 열 6개를 추가하는 방법을 보여줍니다.
```
=> select * from aurora_stat_database() where datid=14717;
-[ RECORD 1 ]------------+------------------------------
datid | 14717
datname | postgres
numbackends | 1
xact_commit | 223
xact_rollback | 4
blks_read | 1059
blks_hit | 11456
tup_returned | 27746
tup_fetched | 5220
tup_inserted | 165
tup_updated | 42
tup_deleted | 91
conflicts | 0
temp_files | 0
temp_bytes | 0
deadlocks | 0
checksum_failures |
checksum_last_failure |
blk_read_time | 3358.689
blk_write_time | 0
session_time | 1076007.997
active_time | 3684.371
idle_in_transaction_time | 0
sessions | 10
sessions_abandoned | 0
sessions_fatal | 0
sessions_killed | 0
stats_reset | 2023-01-12 20:15:17.370601+00
orcache_blks_hit | 425
orcache_blk_read_time | 89.934
storage_blks_read | 623
storage_blk_read_time | 3254.914
local_blks_read | 0
local_blk_read_time | 0
```
# aurora\$1stat\$1dml\$1activity
Aurora PostgreSQL 클러스터의 데이터베이스에서 각 DML(데이터 조작 언어) 작업 유형에 대한 누적 활동을 보고합니다.
## 구문
```
aurora_stat_dml_activity(database_oid)
```
## 인수
*database\$1oid*
Aurora PostgreSQL 클러스터에 있는 데이터베이스의 객체 ID(OID)입니다.
## 반환 타입
SETOF 레코드
## 사용 노트
`aurora_stat_dml_activity` 함수는 PostgreSQL 엔진 11.6 이상과 호환되는 Aurora PostgreSQL 릴리스 3.1에서만 사용할 수 있습니다.
많은 수의 데이터베이스가 있는 Aurora PostgreSQL 클러스터에서 이 함수를 사용하여 DML 작업이 많거나 느린 데이터베이스 또는 둘 다 해당하는 데이터베이스를 식별합니다.
`aurora_stat_dml_activity` 함수가 실행된 횟수와 SELECT, INSERT, UPDATE 및 DELETE 작업의 누적 대기 시간을 마이크로초 단위로 반환합니다. 이 보고서에는 성공적인 DML 작업만 포함됩니다.
PostgreSQL 통계 액세스 함수 `pg_stat_reset`을 사용하여이 통계를 재설정할 수 있습니다. `pg_stat_get_db_stat_reset_time` 함수를 사용하면 이 통계가 마지막으로 재설정된 시간을 확인할 수 있습니다. PostgreSQL 통계 액세스 함수에 대한 자세한 내용은 PostgreSQL 설명서에서 [통계 수집기](https://www.postgresql.org/docs/9.1/monitoring-stats.html)를 참조하세요.
## 예시
다음 예는 연결된 데이터베이스에 대한 DML 작업 통계를 보고하는 방법을 보여줍니다.
```
––Define the oid variable from connected database by using \gset
=> SELECT oid,
datname
FROM pg_database
WHERE datname=(select current_database()) \gset
=> SELECT *
FROM aurora_stat_dml_activity(:oid);
select_count | select_latency_microsecs | insert_count | insert_latency_microsecs | update_count | update_latency_microsecs | delete_count | delete_latency_microsecs
--------------+--------------------------+--------------+--------------------------+--------------+--------------------------+--------------+--------------------------
178957 | 66684115 | 171065 | 28876649 | 519538 | 1454579206167 | 1 | 53027
–– Showing the same results with expanded display on
=> SELECT *
FROM aurora_stat_dml_activity(:oid);
-[ RECORD 1 ]------------+--------------
select_count | 178957
select_latency_microsecs | 66684115
insert_count | 171065
insert_latency_microsecs | 28876649
update_count | 519538
update_latency_microsecs | 1454579206167
delete_count | 1
delete_latency_microsecs | 53027
```
다음 예는 Aurora PostgreSQL 클러스터의 모든 데이터베이스에 대한 DML 작업 통계를 보여줍니다. 이 클러스터에는 `postgres`와 `mydb`라는 두 개의 데이터베이스가 있습니다. 쉼표로 구분된 목록은 `select_count`, `select_latency_microsecs`, `insert_count`, `insert_latency_microsecs`, `update_count`, `update_latency_microsecs`, `delete_count` 및 `delete_latency_microsecs` 필드와 일치합니다.
Aurora PostgreSQL은 `rdsadmin`이라는 시스템 데이터베이스를 만들고 이 데이터베이스를 사용하여 백업, 복원, 상태 확인, 복제 등의 관리 작업을 지원합니다. 이러한 DML 작업은 Aurora PostgreSQL 클러스터에 영향을 주지 않습니다.
```
=> SELECT oid,
datname,
aurora_stat_dml_activity(oid)
FROM pg_database;
oid | datname | aurora_stat_dml_activity
-------+----------------+-----------------------------------------------------------------
14006 | template0 | (,,,,,,,)
16384 | rdsadmin | (2346623,1211703821,4297518,817184554,0,0,0,0)
1 | template1 | (,,,,,,,)
14007 | postgres | (178961,66716329,171065,28876649,519538,1454579206167,1,53027)
16401 | mydb | (200246,64302436,200036,107101855,600000,83659417514,0,0)
```
다음 예는 가독성을 높이기 위해 열로 구성된 모든 데이터베이스의 DML 작업 통계를 보여줍니다.
```
SELECT db.datname,
BTRIM(SPLIT_PART(db.asdmla::TEXT, ',', 1), '()') AS select_count,
BTRIM(SPLIT_PART(db.asdmla::TEXT, ',', 2), '()') AS select_latency_microsecs,
BTRIM(SPLIT_PART(db.asdmla::TEXT, ',', 3), '()') AS insert_count,
BTRIM(SPLIT_PART(db.asdmla::TEXT, ',', 4), '()') AS insert_latency_microsecs,
BTRIM(SPLIT_PART(db.asdmla::TEXT, ',', 5), '()') AS update_count,
BTRIM(SPLIT_PART(db.asdmla::TEXT, ',', 6), '()') AS update_latency_microsecs,
BTRIM(SPLIT_PART(db.asdmla::TEXT, ',', 7), '()') AS delete_count,
BTRIM(SPLIT_PART(db.asdmla::TEXT, ',', 8), '()') AS delete_latency_microsecs
FROM (SELECT datname,
aurora_stat_dml_activity(oid) AS asdmla
FROM pg_database
) AS db;
datname | select_count | select_latency_microsecs | insert_count | insert_latency_microsecs | update_count | update_latency_microsecs | delete_count | delete_latency_microsecs
----------------+--------------+--------------------------+--------------+--------------------------+--------------+--------------------------+--------------+--------------------------
template0 | | | | | | | |
rdsadmin | 4206523 | 2478812333 | 7009414 | 1338482258 | 0 | 0 | 0 | 0
template1 | | | | | | | |
fault_test | 66 | 452099 | 0 | 0 | 0 | 0 | 0 | 0
db_access_test | 1 | 5982 | 0 | 0 | 0 | 0 | 0 | 0
postgres | 42035 | 95179203 | 5752 | 2678832898 | 21157 | 441883182488 | 2 | 1520
mydb | 71 | 453514 | 0 | 0 | 1 | 190 | 1 | 152
```
다음 예는 OID가 `16401`인 데이터베이스의 각 DML 작업에 대한 평균 누적 대기 시간(누적 대기 시간을 카운트로 나눈 값)을 보여줍니다.
```
=> SELECT select_count,
select_latency_microsecs,
select_latency_microsecs/NULLIF(select_count,0) select_latency_per_exec,
insert_count,
insert_latency_microsecs,
insert_latency_microsecs/NULLIF(insert_count,0) insert_latency_per_exec,
update_count,
update_latency_microsecs,
update_latency_microsecs/NULLIF(update_count,0) update_latency_per_exec,
delete_count,
delete_latency_microsecs,
delete_latency_microsecs/NULLIF(delete_count,0) delete_latency_per_exec
FROM aurora_stat_dml_activity(16401);
-[ RECORD 1 ]------------+-------------
select_count | 451312
select_latency_microsecs | 80205857
select_latency_per_exec | 177
insert_count | 451001
insert_latency_microsecs | 123667646
insert_latency_per_exec | 274
update_count | 1353067
update_latency_microsecs | 200900695615
update_latency_per_exec | 148478
delete_count | 12
delete_latency_microsecs | 448
delete_latency_per_exec | 37
```
# aurora\$1stat\$1get\$1db\$1commit\$1latency
Aurora PostgreSQL 데이터베이스의 누적 커밋 대기 시간을 마이크로초 단위로 가져옵니다. [*커밋 대기 시간(Commit latency)*]은 클라이언트가 커밋 요청을 제출하는 시점과 커밋 승인을 수신하는 시점 사이의 시간으로 측정됩니다.
## 구문
```
aurora_stat_get_db_commit_latency(database_oid)
```
## 인수
*database\$1oid*
Aurora PostgreSQL 데이터베이스의 객체 ID(OID)입니다.
## 반환 타입
SETOF 레코드
## 사용 노트
Amazon CloudWatch는 이 함수를 사용하여 평균 커밋 대기 시간을 계산합니다. Amazon CloudWatch 지표와 긴 커밋 대기 시간을 해결하는 방법에 대한 자세한 내용은 [Amazon RDS 콘솔에서 지표 보기](USER_Monitoring.md) 및 [Amazon CloudWatch 지표를 사용하여 Amazon RDS에 대한 더 나은 의사 결정 내리기](https://aws.amazon.com/blogs/database/making-better-decisions-about-amazon-rds-with-amazon-cloudwatch-metrics/)를 참조하세요.
PostgreSQL 통계 액세스 함수 `pg_stat_reset`을 사용하여이 통계를 재설정할 수 있습니다. `pg_stat_get_db_stat_reset_time` 함수를 사용하면 이 통계가 마지막으로 재설정된 시간을 확인할 수 있습니다. PostgreSQL 통계 액세스 함수에 대한 자세한 내용은 PostgreSQL 설명서에서 [통계 수집기](https://www.postgresql.org/docs/9.1/monitoring-stats.html)를 참조하세요.
## 예시
다음 예에서는 `pg_database` 클러스터의 각 데이터베이스에 대한 누적 커밋 대기 시간을 가져옵니다.
```
=> SELECT oid,
datname,
aurora_stat_get_db_commit_latency(oid)
FROM pg_database;
oid | datname | aurora_stat_get_db_commit_latency
-------+----------------+-----------------------------------
14006 | template0 | 0
16384 | rdsadmin | 654387789
1 | template1 | 0
16401 | mydb | 229556
69768 | postgres | 22011
```
다음 예에서는 현재 연결된 데이터베이스에 대한 누적 커밋 대기 시간을 가져옵니다. 이 예에서는 `aurora_stat_get_db_commit_latency` 함수를 호출하기 전에 먼저 `\gset`을 사용하여 `oid` 인수의 변수를 정의하고 연결된 데이터베이스에서 해당 값을 설정합니다.
```
––Get the oid value from the connected database before calling aurora_stat_get_db_commit_latency
=> SELECT oid
FROM pg_database
WHERE datname=(SELECT current_database()) \gset
=> SELECT *
FROM aurora_stat_get_db_commit_latency(:oid);
aurora_stat_get_db_commit_latency
-----------------------------------
1424279160
```
다음 예에서는 `pg_database` 클러스터의 `mydb` 데이터베이스에 대한 누적 커밋 대기 시간을 가져옵니다. 그런 다음, `pg_stat_reset` 함수를 사용하여 이 통계를 재설정하고 결과를 표시합니다. 마지막으로 `pg_stat_get_db_stat_reset_time` 함수를 사용하여 이 통계가 마지막으로 재설정된 시간을 확인합니다.
```
=> SELECT oid,
datname,
aurora_stat_get_db_commit_latency(oid)
FROM pg_database
WHERE datname = 'mydb';
oid | datname | aurora_stat_get_db_commit_latency
-------+-----------+-----------------------------------
16427 | mydb | 3320370
=> SELECT pg_stat_reset();
pg_stat_reset
---------------
=> SELECT oid,
datname,
aurora_stat_get_db_commit_latency(oid)
FROM pg_database
WHERE datname = 'mydb';
oid | datname | aurora_stat_get_db_commit_latency
-------+-----------+-----------------------------------
16427 | mydb | 6
=> SELECT *
FROM pg_stat_get_db_stat_reset_time(16427);
pg_stat_get_db_stat_reset_time
--------------------------------
2021-04-29 21:36:15.707399+00
```
# aurora\$1stat\$1logical\$1wal\$1cache
슬롯당 미리 쓰기 로그(WAL) 캐시 사용량을 보여 줍니다.
## 구문
```
SELECT * FROM aurora_stat_logical_wal_cache()
```
## 인수
없음
## 반환 타입
다음 열이 있는 SETOF 레코드:
+ `name` - 복제 슬롯의 이름입니다.
+ `active_pid` - walsender 프로세스의 ID입니다.
+ `cache_hit` - 마지막 재설정 이후 wal 캐시 총 적중 횟수입니다.
+ `cache_miss` - 마지막 재설정 이후 wal 캐시 총 미적중 횟수입니다.
+ `blks_read`— wal 캐시 읽기 요청 총합입니다.
+ `hit_rate` – WAL 캐시 적중률(cache\$1hit / blks\$1read)입니다.
+ `last_reset_timestamp` - 마지막으로 카운터를 재설정한 시간입니다.
## 사용 노트
이 함수는 다음 Aurora PostgreSQL 버전에서 사용할 수 있습니다.
+ 15.2 이상의 모든 버전
+ 14.7 이상 버전
+ 13.8 이상 버전
+ 12.12 이상 버전
+ 11.17 이상 버전
## 예시
다음 예제에서는 활성 `aurora_stat_logical_wal_cache` 함수가 하나뿐인 복제 슬롯 2개를 확인할 수 있습니다.
```
=> SELECT *
FROM aurora_stat_logical_wal_cache();
name | active_pid | cache_hit | cache_miss | blks_read | hit_rate | last_reset_timestamp
------------+------------+-----------+------------+-----------+----------+-------------------------------
test_slot1 | 79183 | 24 | 0 | 24 | 100.00% | 2022-08-05 17:39:56.830635+00
test_slot2 | | 1 | 0 | 1 | 100.00% | 2022-08-05 17:34:04.036795+00
(2 rows)
```
# aurora\$1stat\$1memctx\$1usage
각 PostgreSQL 프로세스의 메모리 컨텍스트 사용량을 보고합니다.
## 구문
```
aurora_stat_memctx_usage()
```
## 인수
없음
## 반환 타입
다음 열이 있는 SETOF 레코드:
+ `pid` - 프로세스의 ID입니다.
+ `name` - 메모리 컨텍스트의 이름입니다.
+ `allocated` - 메모리 컨텍스트가 기본 메모리 하위 시스템에서 가져온 바이트 수입니다.
+ `used` - 메모리 컨텍스트의 클라이언트에 커밋된 바이트 수입니다.
+ `instances` - 이 유형의 현재 존재하는 컨텍스트 수입니다.
## 사용 노트
이 함수는 PostgreSQL 프로세스의 메모리 컨텍스트 사용량을 표시합니다. 일부 프로세스에는 `anonymous`라는 레이블이 지정되어 있습니다. 프로세스는 제한된 키워드를 포함하므로 노출되지 않습니다.
이 함수는 다음 Aurora PostgreSQL 버전 이상에서 사용할 수 있습니다.
+ 15.3 이상의 15 버전
+ 14.8 이상의 14 버전
+ 13.11 이상의 13 버전
+ 12.15 이상의 12 버전
+ 11.20 이상의 11 버전
## 예시
다음 예제에서는 `aurora_stat_memctx_usage` 함수 호출의 결과를 보여줍니다.
```
=> SELECT *
FROM aurora_stat_memctx_usage();
pid| name | allocated | used | instances
-------+---------------------------------+-----------+---------+-----------
123864 | Miscellaneous | 19520 | 15064 | 3
123864 | Aurora File Context | 8192 | 616 | 1
123864 | Aurora WAL Context | 8192 | 296 | 1
123864 | CacheMemoryContext | 524288 | 422600 | 1
123864 | Catalog tuple context | 16384 | 13736 | 1
123864 | ExecutorState | 32832 | 28304 | 1
123864 | ExprContext | 8192 | 1720 | 1
123864 | GWAL record construction | 1024 | 832 | 1
123864 | MdSmgr | 8192 | 296 | 1
123864 | MessageContext | 532480 | 353832 | 1
123864 | PortalHeapMemory | 1024 | 488 | 1
123864 | PortalMemory | 8192 | 576 | 1
123864 | printtup | 8192 | 296 | 1
123864 | RelCache hash table entries | 8192 | 8152 | 1
123864 | RowDescriptionContext | 8192 | 1344 | 1
123864 | smgr relation context | 8192 | 296 | 1
123864 | Table function arguments | 8192 | 352 | 1
123864 | TopTransactionContext | 8192 | 632 | 1
123864 | TransactionAbortContext | 32768 | 296 | 1
123864 | WAL record construction | 50216 | 43904 | 1
123864 | hash table | 65536 | 52744 | 6
123864 | Relation metadata | 191488 | 124240 | 87
104992 | Miscellaneous | 9280 | 7728 | 3
104992 | Aurora File Context | 8192 | 376 | 1
104992 | Aurora WAL Context | 8192 | 296 | 1
104992 ||Autovacuum Launcher | 8192 | 296 | 1
104992 | Autovacuum database list | 16384 | 744 | 2
104992 | CacheMemoryContext | 262144 | 140288 | 1
104992 | Catalog tuple context | 8192 | 296 | 1
104992 | GWAL record construction | 1024 | 832 | 1
104992 | MdSmgr | 8192 | 296 | 1
104992 | PortalMemory | 8192 | 296 | 1
104992 | RelCache hash table entries | 8192 | 296 | 1
104992 | smgr relation context | 8192 | 296 | 1
104992 | Autovacuum start worker (tmp) | 8192 | 296 | 1
104992 | TopTransactionContext | 16384 | 592 | 2
104992 | TransactionAbortContext | 32768 | 296 | 1
104992 | WAL record construction | 50216 | 43904 | 1
104992 | hash table | 49152 | 34024 | 4
(39 rows)
```
일부 제한된 키워드는 숨겨지고 출력은 다음과 같이 표시됩니다.
```
postgres=>SELECT *
FROM aurora_stat_memctx_usage();
pid| name | allocated | used | instances
-------+---------------------------------+-----------+---------+-----------
5482 | anonymous | 8192 | 456 | 1
5482 | anonymous | 8192 | 296 | 1
```
# aurora\$1stat\$1optimized\$1reads\$1cache
이 함수는 계층형 캐시 통계를 보여줍니다.
## 구문
```
aurora_stat_optimized_reads_cache()
```
## 인수
없음
## 반환 타입
다음 열이 있는 SETOF 레코드:
+ `total_size` - 최적화된 총 읽기 캐시 크기입니다.
+ `used_size` - 최적화된 읽기 캐시에서 사용된 페이지 크기입니다.
## 사용 노트
이 함수는 다음 Aurora PostgreSQL 버전에서 사용할 수 있습니다.
+ 15.4 이상의 15 버전
+ 14.9 이상의 14 버전
## 예시
다음 예는 r6gd.8xlarge 인스턴스의 출력을 보여줍니다.
```
=> select pg_size_pretty(total_size) as total_size, pg_size_pretty(used_size)
as used_size from aurora_stat_optimized_reads_cache();
total_size | used_size
-----------+-----------
1054 GB | 975 GB
```
# aurora\$1stat\$1plans
추적된 모든 실행 계획에 대해 하나의 행을 반환합니다.
## 구문
```
aurora_stat_plans(
showtext
)
```
## 인수
+ showtext - 쿼리와 계획 텍스트를 표시합니다. 유효한 값은 NULL, true 또는 false입니다. True인 경우 쿼리와 계획 텍스트를 표시합니다.
## 반환 타입
`aurora_stat_statements`의 모든 열과 다음의 추가 열을 포함하는 추적된 각 계획의 행 하나를 반환합니다.
+ planid – 계획 식별자
+ explain\$1plan — 계획 텍스트 설명
+ plan\$1type:
+ `no plan` - 계획이 캡처되지 않음
+ `estimate` - 예상 비용을 포함하여 캡처된 계획
+ `actual` - EXPLAIN ANALYZE로 캡처된 계획
+ plan\$1captured\$1time - 계획이 마지막으로 캡처된 시간
## 사용 노트
계획을 추적하려면 `aurora_compute_plan_id`가 활성화되어 있어야 하고 `pg_stat_statements`가 `shared_preload_libraries`에 있어야 합니다.
사용 가능한 계획 수는 `pg_stat_statements.max` 파라미터에 설정된 값에 따라 제어됩니다. `aurora_compute_plan_id`가 활성화되면 `aurora_stat_plans`에서 지정된 값까지 계획을 추적할 수 있습니다.
이 함수는 Aurora PostgreSQL 버전 14.10 및 15.5 이상 모든 버전의 릴리스부터 사용할 수 있습니다.
## 예시
아래 예제에서는 쿼리 식별자 -5471422286312252535에 대한 두 개의 계획이 캡처되고 해당 문 통계는 planid에 의해 추적됩니다.
```
db1=# select calls, total_exec_time, planid, plan_captured_time, explain_plan
db1-# from aurora_stat_plans(true)
db1-# where queryid = '-5471422286312252535'
calls | total_exec_time | planid | plan_captured_time | explain_plan
---------+--------------------+-------------+-------------------------------+------------------------------------------------------------------
1532632 | 3209846.097107853 | 1602979607 | 2023-10-31 03:27:16.925497+00 | Update on pgbench_branches +
| | | | -> Bitmap Heap Scan on pgbench_branches +
| | | | Recheck Cond: (bid = 76) +
| | | | -> Bitmap Index Scan on pgbench_branches_pkey +
| | | | Index Cond: (bid = 76)
61365 | 124078.18012200127 | -2054628807 | 2023-10-31 03:20:09.85429+00 | Update on pgbench_branches +
| | | | -> Index Scan using pgbench_branches_pkey on pgbench_branches+
| | | | Index Cond: (bid = 17)
```
# aurora\$1stat\$1reset\$1wal\$1cache
논리적 wal 캐시의 카운터를 재설정합니다.
## 구문
특정 슬롯을 재설정하는 방법
```
SELECT * FROM aurora_stat_reset_wal_cache('slot_name')
```
모든 슬롯을 재설정하는 방법
```
SELECT * FROM aurora_stat_reset_wal_cache(NULL)
```
## 인수
`NULL` 또는 `slot_name`
## 반환 타입
상태 메시지, 텍스트 문자열
+ 논리적 Wal 캐시 카운터 재설정 - 성공 메시지입니다. 함수가 성공하면 이 텍스트가 반환됩니다.
+ 복제 슬롯을 찾을 수 없습니다. 다시 시도하세요. - 오류 메시지입니다. 함수가 실패하면 이 텍스트가 반환됩니다.
## 사용 노트
이 함수는 다음 버전에서 사용할 수 있습니다.
+ Aurora PostgreSQL 14.5 이상
+ Aurora PostgreSQL 버전 13.8 이상
+ Aurora PostgreSQL 버전 12.12 이상
+ Aurora PostgreSQL 버전 11.17 이상
## 예시
다음 예제에서는 `aurora_stat_reset_wal_cache` 함수를 사용하여 `test_results`라는 슬롯을 재설정한 다음, 존재하지 않는 슬롯의 재설정을 시도합니다.
```
=> SELECT *
FROM aurora_stat_reset_wal_cache('test_slot');
aurora_stat_reset_wal_cache
--------------------------------------
Reset the logical wal cache counter.
(1 row)
=> SELECT *
FROM aurora_stat_reset_wal_cache('slot-not-exist');
aurora_stat_reset_wal_cache
-----------------------------------------------
Replication slot not found. Please try again.
(1 row)
```
# aurora\$1stat\$1resource\$1usage
모든 Aurora PostgreSQL 백엔드 프로세스에 대한 백엔드 리소스 지표 및 cpu 사용량으로 구성된 실시간 리소스 사용률을 보고합니다.
## 구문
```
aurora_stat_resource_usage()
```
## 인수
없음
## 반환 타입
다음 열이 있는 SETOF 레코드:
+ pid - 프로세스 식별자
+ allocated\$1memory - 프로세스별로 할당된 총 메모리(바이트)
+ used\$1memory - 프로세스별로 실제로 사용된 메모리(바이트)
+ cpu\$1usage\$1percent - 프로세스의 CPU 사용률(%)
## 사용 노트
이 함수는 각 Aurora PostgreSQL 백엔드 프로세스의 백엔드 리소스 사용량을 표시합니다.
이 함수는 다음 Aurora PostgreSQL 버전 이상에서 사용할 수 있습니다.
+ Aurora PostgreSQL 17.5 이상 17 버전
+ Aurora PostgreSQL 16.9 이상 16 버전
+ Aurora PostgreSQL 15.13 이상 15 버전
+ Aurora PostgreSQL 14.18 이상 14 버전
+ Aurora PostgreSQL 13.21 이상 13 버전
## 예시
다음 예에서는 `aurora_stat_resource_usage` 함수의 출력을 보여줍니다.
```
=> select * from aurora_stat_resource_usage();
pid | allocated_memory | used_memory | cpu_usage_percent
------+------------------+-------------+-----------------------
666 | 1074032 | 333544 | 0.00729274882897963
667 | 787312 | 287360 | 0.0029263928146372746
668 | 3076776 | 1563488 | 0.006013116835953961
684 | 803744 | 307480 | 0.002226855426881142
2401 | 1232992 | 943144 | 0
647 | 8000 | 944 | 0.48853387812429855
659 | 319344 | 243000 | 0.0004135602076683591
663 | 262000 | 185736 | 0.008181301476644002
664 | 9024 | 1216 | 0.10992313082653653
(9 rows)
```
# aurora\$1stat\$1statements
모든 `pg_stat_statements` 열을 표시하고 끝에 열을 더 추가합니다.
## 구문
```
aurora_stat_statements(showtext boolean)
```
## 인수
showtext 부울**
## 반환 타입
모든 `pg_stat_statements` 열과 다음과 같은 추가 열이 포함된 SETOF 레코드. `pg_stat_statements` 열에 대한 자세한 내용은 [https://www.postgresql.org/docs/current/pgstatstatements.html](https://www.postgresql.org/docs/current/pgstatstatements.html) 섹션을 참조하세요.
`pg_stat_statements_reset()`을 사용하여 이 함수의 통계를 재설정할 수 있습니다.
+ `storage_blks_read` - 이 문이 Aurora 스토리지에서 읽은 총 공유 블록 수입니다.
+ `orcache_blks_hit` - 이 문에 의한 최적화된 읽기 캐시 적중률의 총 수입니다.
+ `storage_blk_read_time` - `track_io_timing`이 활성화된 경우 Aurora 스토리지에서 공유된 블록을 읽는 데 문이 소요한 총 시간을 밀리초 단위로 추적합니다. 활성화되지 않은 경우 값은 0입니다. 자세한 내용은 [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING)을 참조하세요.
+ `local_blk_read_time` - `track_io_timing`이 활성화된 경우 로컬 블록을 읽는 데 문이 소요한 총 시간을 밀리초 단위로 추적합니다. 활성화되지 않은 경우 값은 0입니다. 자세한 내용은 [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING)을 참조하세요.
+ `orcache_blk_read_time` - `track_io_timing`이 활성화된 경우 최적화된 읽기 캐시에서 공유된 블록을 읽는 데 문이 소요한 총 시간을 밀리초 단위로 추적합니다. 활성화되지 않은 경우 값은 0입니다. 자세한 내용은 [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING)을 참조하세요.
+ `total_plan_peakmem` – 이 문에 대한 모든 직접 호출의 계획 단계 중 피크 메모리 값의 총계입니다. 문을 계획하는 동안 평균 피크 메모리를 확인하려면 이 값을 직접 호출 수로 나누세요.
+ `min_plan_peakmem` – 이 문에 대한 모든 직접 호출을 계획하는 동안 나타난 최소 피크 메모리 값입니다.
+ `max_plan_peakmem` – 이 문에 대한 모든 직접 호출을 계획하는 동안 나타난 최대 피크 메모리 값입니다.
+ `total_exec_peakmem` – 이 문에 대한 모든 직접 호출의 실행 단계 중 피크 메모리 값의 총계입니다. 문을 실행하는 동안 평균 피크 메모리를 확인하려면 이 값을 직접 호출 수로 나누세요.
+ `min_exec_peakmem` – 이 문에 대한 모든 직접 호출을 실행하는 동안 나타난 최소 피크 메모리 값입니다.
+ `max_exec_peakmem` – 이 문에 대한 모든 직접 호출을 실행하는 동안 나타난 최대 피크 메모리 값입니다.
**참고**
`total_plan_peakmen`, `min_plan_peakmem`, `max_plan_peakmem`은 `pg_stat_statements.track_planning` 설정이 켜져 있을 때만 모니터링됩니다.
## 사용 노트
aurora\$1stat\$1statements() 함수를 사용하려면 `shared_preload_libraries` 파라미터에 `pg_stat_statements` 확장을 포함해야 합니다.
이 함수는 다음 Aurora PostgreSQL 버전에서 사용할 수 있습니다.
+ 15.4 이상의 15 버전
+ 14.9 이상의 14 버전
피크 메모리를 표시하는 열은 다음 버전에서 사용할 수 있습니다.
+ 16.3 이상 버전
+ 15.7 이상 버전
+ 14.12 이상 버전
## 예시
다음 예는 모든 pg\$1stat\$1statements 열을 포함하고 끝에 새 열 11개를 추가하는 방법을 보여줍니다.
```
=> select * from aurora_stat_statements(true) where query like 'with window_max%';
-[ RECORD 1 ]----------+------------------------------------------------------------------------------------------------
userid | 16409
dbid | 5
toplevel | t
queryid | -8347523682669847482
query | with window_max as (select custid, max(scratch) over (order by scratch rows between $1 preceding
and $2 following) wmax from ts) select sum(wmax), max(custid) from window_max
plans | 0
total_plan_time | 0
min_plan_time | 0
max_plan_time | 0
mean_plan_time | 0
stddev_plan_time | 0
calls | 4
total_exec_time | 254.105121
min_exec_time | 57.503164000000005
max_exec_time | 68.687418
mean_exec_time | 63.52628025
stddev_exec_time | 5.150765359979643
rows | 4
shared_blks_hit | 200192
shared_blks_read | 0
shared_blks_dirtied | 0
shared_blks_written | 0
local_blks_hit | 0
local_blks_read | 0
local_blks_dirtied | 0
local_blks_written | 0
temp_blks_read | 0
temp_blks_written | 0
blk_read_time | 0
blk_write_time | 0
temp_blk_read_time | 0
temp_blk_write_time | 0
wal_records | 0
wal_fpi | 0
wal_bytes | 0
jit_functions | 0
jit_generation_time | 0
jit_inlining_count | 0
jit_inlining_time | 0
jit_optimization_count | 0
jit_optimization_time | 0
jit_emission_count | 0
jit_emission_time | 0
storage_blks_read | 0
orcache_blks_hit | 0
storage_blk_read_time | 0
local_blk_read_time | 0
orcache_blk_read_time | 0
total_plan_peakmem | 0
min_plan_peakmem | 0
max_plan_peakmem | 0
total_exec_peakmem | 6356224
min_exec_peakmem | 1589056
max_exec_peakmem | 1589056
```
# aurora\$1stat\$1system\$1waits
Aurora PostgreSQL DB 인스턴스에 대한 대기 이벤트 정보를 보고합니다.
## 구문
```
aurora_stat_system_waits()
```
## 인수
없음
## 반환 타입
SETOF 레코드
## 사용 노트
이 함수는 현재 연결된 DB 인스턴스에 의해 생성된 각 대기 이벤트의 누적 대기 횟수와 누적 대기 시간을 반환합니다.
반환되는 레코드 세트에는 다음 필드가 포함됩니다.
+ `type_id` - 대기 이벤트 유형의 ID입니다.
+ `event_id` - 대기 이벤트의 ID입니다.
+ `waits` - 대기 이벤트가 발생한 횟수입니다.
+ `wait_time` - 이 이벤트를 기다리는 데 소요된 총 시간(마이크로초)입니다.
이 함수에서 반환되는 통계는 DB 인스턴스가 다시 시작될 때 재설정됩니다.
## 예시
다음 예제에서는 `aurora_stat_system_waits` 함수 호출의 결과를 보여줍니다.
```
=> SELECT *
FROM aurora_stat_system_waits();
type_id | event_id | waits | wait_time
---------+-----------+-----------+--------------
1 | 16777219 | 11 | 12864
1 | 16777220 | 501 | 174473
1 | 16777270 | 53171 | 23641847
1 | 16777271 | 23 | 319668
1 | 16777274 | 60 | 12759
.
.
.
10 | 167772231 | 204596 | 790945212
10 | 167772232 | 2 | 47729
10 | 167772234 | 1 | 888
10 | 167772235 | 2 | 64
```
다음 예는 이 함수를 `aurora_stat_wait_event` 및 `aurora_stat_wait_type`과 함께 사용하여 가독성이 더 높은 결과를 생성하는 방법을 보여줍니다.
```
=> SELECT type_name,
event_name,
waits,
wait_time
FROM aurora_stat_system_waits()
NATURAL JOIN aurora_stat_wait_event()
NATURAL JOIN aurora_stat_wait_type();
type_name | event_name | waits | wait_time
-----------+------------------------+----------+--------------
LWLock | XidGenLock | 11 | 12864
LWLock | ProcArrayLock | 501 | 174473
LWLock | buffer_content | 53171 | 23641847
LWLock | rdsutils | 2 | 12764
Lock | tuple | 75686 | 2033956052
Lock | transactionid | 1765147 | 47267583409
Activity | AutoVacuumMain | 136868 | 56305604538
Activity | BgWriterHibernate | 7486 | 55266949471
Activity | BgWriterMain | 7487 | 1508909964
.
.
.
IO | SLRURead | 3 | 11756
IO | WALWrite | 52544463 | 388850428
IO | XactSync | 187073 | 597041642
IO | ClogRead | 2 | 47729
IO | OutboundCtrlRead | 1 | 888
IO | OutboundCtrlWrite | 2 | 64
```
# aurora\$1stat\$1wait\$1event
Aurora PostgreSQL에 대해 지원되는 대기 이벤트를 모두 나열합니다. Aurora PostgreSQL 대기 이벤트에 대한 자세한 내용은 [Amazon Aurora PostgreSQL 대기 이벤트](AuroraPostgreSQL.Reference.Waitevents.md) 섹션을 참조하세요.
## 구문
```
aurora_stat_wait_event()
```
## 인수
없음
## 반환 타입
다음 열이 있는 SETOF 레코드:
+ type\$1id - 대기 이벤트 유형의 ID입니다.
+ - 대기 이벤트의 ID입니다.
+ type\$1name - 대기 유형 이름
+ event\$1name - 대기 이벤트 이름
## 사용 노트
ID 대신 이벤트 유형을 사용한 이벤트 이름을 보려면 이 함수를 `aurora_stat_wait_type` 및 `aurora_stat_system_waits`와 같은 다른 함수와 함께 사용합니다. 이 함수에서 반환되는 대기 이벤트 이름은 `aurora_wait_report` 함수에서 반환되는 이름과 동일합니다.
## 예시
다음 예제에서는 `aurora_stat_wait_event` 함수 호출의 결과를 보여줍니다.
```
=> SELECT *
FROM aurora_stat_wait_event();
type_id | event_id | event_name
---------+-----------+-------------------------------------------
1 | 16777216 |
1 | 16777217 | ShmemIndexLock
1 | 16777218 | OidGenLock
1 | 16777219 | XidGenLock
.
.
.
9 | 150994945 | PgSleep
9 | 150994946 | RecoveryApplyDelay
10 | 167772160 | BufFileRead
10 | 167772161 | BufFileWrite
10 | 167772162 | ControlFileRead
.
.
.
10 | 167772226 | WALInitWrite
10 | 167772227 | WALRead
10 | 167772228 | WALSync
10 | 167772229 | WALSyncMethodAssign
10 | 167772230 | WALWrite
10 | 167772231 | XactSync
.
.
.
11 | 184549377 | LsnAllocate
```
다음 예에서는 `aurora_stat_wait_type`과 `aurora_stat_wait_event`를 함께 사용하여 유형 이름과 이벤트 이름을 반환함으로써 가독성을 높입니다.
```
=> SELECT *
FROM aurora_stat_wait_type() t
JOIN aurora_stat_wait_event() e
ON t.type_id = e.type_id;
type_id | type_name | type_id | event_id | event_name
---------+-----------+---------+-----------+-------------------------------------------
1 | LWLock | 1 | 16777216 |
1 | LWLock | 1 | 16777217 | ShmemIndexLock
1 | LWLock | 1 | 16777218 | OidGenLock
1 | LWLock | 1 | 16777219 | XidGenLock
1 | LWLock | 1 | 16777220 | ProcArrayLock
.
.
.
3 | Lock | 3 | 50331648 | relation
3 | Lock | 3 | 50331649 | extend
3 | Lock | 3 | 50331650 | page
3 | Lock | 3 | 50331651 | tuple
.
.
.
10 | IO | 10 | 167772214 | TimelineHistorySync
10 | IO | 10 | 167772215 | TimelineHistoryWrite
10 | IO | 10 | 167772216 | TwophaseFileRead
10 | IO | 10 | 167772217 | TwophaseFileSync
.
.
.
11 | LSN | 11 | 184549376 | LsnDurable
```
# aurora\$1stat\$1wait\$1type
Aurora PostgreSQL에 대해 지원되는 대기 유형을 모두 나열합니다.
## 구문
```
aurora_stat_wait_type()
```
## 인수
없음
## 반환 타입
다음 열이 있는 SETOF 레코드:
+ type\$1id - 대기 이벤트 유형의 ID입니다.
+ type\$1name - 대기 유형 이름
## 사용 노트
ID 대신 대기 이벤트 유형을 사용한 대기 이벤트 이름을 보려면 이 함수를 `aurora_stat_wait_event` 및 `aurora_stat_system_waits`와 같은 다른 함수와 함께 사용합니다. 이 함수에서 반환되는 대기 유형 이름은 `aurora_wait_report` 함수에서 반환되는 이름과 동일합니다.
## 예시
다음 예제에서는 `aurora_stat_wait_type` 함수 호출의 결과를 보여줍니다.
```
=> SELECT *
FROM aurora_stat_wait_type();
type_id | type_name
---------+-----------
1 | LWLock
3 | Lock
4 | BufferPin
5 | Activity
6 | Client
7 | Extension
8 | IPC
9 | Timeout
10 | IO
11 | LSN
```
# aurora\$1version
Amazon Aurora PostgreSQL 호환 버전 번호의 문자열 값을 반환합니다.
## 구문
```
aurora_version()
```
## 인수
없음
## 반환 타입
CHAR 또는 VARCHAR 문자열
## 사용 노트
이 함수는 Amazon Aurora PostgreSQL 호환 버전 데이터베이스 엔진의 버전을 표시합니다. 버전 번호는 *major*.*minor*.*patch* 형식의 문자열로 반환됩니다. Aurora PostgreSQL 버전 번호에 대한 자세한 내용은 [Aurora 버전 번호](AuroraPostgreSQL.Updates.md#AuroraPostgreSQL.Updates.Versions.AuroraNumber) 단원을 참조하세요.
Aurora PostgreSQL DB 클러스터의 유지 관리 기간을 설정하여 마이너 버전 업그레이드를 적용할 시기를 선택할 수 있습니다. 자세한 방법은 [Amazon Aurora DB 클러스터 유지 관리](USER_UpgradeDBInstance.Maintenance.md)을 참조하세요.
Aurora PostgreSQL 버전 13.3, 12.8, 11.13, 10.18 및 다른 모든 이후 버전의 릴리스부터 Aurora 버전 번호는 PostgreSQL 버전 번호를 따릅니다. 모든 Aurora PostgreSQL 릴리스에 대한 자세한 내용은 *Aurora PostgreSQL 릴리스 정보*의 [Amazon Aurora PostgreSQL 업데이트](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Updates.html)를 참조하세요.
## 예시
다음 예제에서는 [PostgreSQL 12.7, Aurora PostgreSQL 릴리스 4.2](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Updates.html#AuroraPostgreSQL.Updates.20180305.42)를 실행 중인 Aurora PostgreSQL DB 클러스터에서 `aurora_version` 함수를 호출한 후 [Aurora PostgreSQL 버전 13.3](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Updates.html#AuroraPostgreSQL.Updates.20180305.133X)을 실행 중인 클러스터에서 같은 함수를 실행한 결과를 보여줍니다.
```
=> SELECT * FROM aurora_version();
aurora_version
----------------
4.2.2
SELECT * FROM aurora_version();
aurora_version
----------------
13.3.0
```
이 예제에서는 다양한 옵션과 함께 함수를 사용하여 Aurora PostgreSQL 버전에 대한 자세한 정보를 얻는 방법을 보여줍니다. 이 예제에는 PostgreSQL 버전 번호와 구별되는 Aurora 버전 번호가 있습니다.
```
=> SHOW SERVER_VERSION;
server_version
----------------
12.7
(1 row)
=> SELECT * FROM aurora_version();
aurora_version
----------------
4.2.2
(1 row)
=> SELECT current_setting('server_version') AS "PostgreSQL Compatiblility";
PostgreSQL Compatiblility
---------------------------
12.7
(1 row)
=> SELECT version() AS "PostgreSQL Compatiblility Full String";
PostgreSQL Compatiblility Full String
-------------------------------------------------------------------------------------------------------------
PostgreSQL 12.7 on aarch64-unknown-linux-gnu, compiled by aarch64-unknown-linux-gnu-gcc (GCC) 7.4.0, 64-bit
(1 row)
=> SELECT 'Aurora: '
|| aurora_version()
|| ' Compatible with PostgreSQL: '
|| current_setting('server_version') AS "Instance Version";
Instance Version
------------------------------------------------
Aurora: 4.2.2 Compatible with PostgreSQL: 12.7
(1 row)
```
다음 예제에서는 이전 예제에서와 동일한 옵션을 가진 함수를 사용합니다. 이 예제에는 PostgreSQL 버전 번호와 구별되는 Aurora 버전 번호가 없습니다.
```
=> SHOW SERVER_VERSION;
server_version
----------------
13.3
=> SELECT * FROM aurora_version();
aurora_version
----------------
13.3.0
=> SELECT current_setting('server_version') AS "PostgreSQL Compatiblility";
PostgreSQL Compatiblility
---------------------------
13.3
=> SELECT version() AS "PostgreSQL Compatiblility Full String";
PostgreSQL Compatiblility Full String
-------------------------------------------------------------------------------------------------
PostgreSQL 13.3 on x86_64-pc-linux-gnu, compiled by x86_64-pc-linux-gnu-gcc (GCC) 7.4.0, 64-bit
=> SELECT 'Aurora: '
|| aurora_version()
|| ' Compatible with PostgreSQL: '
|| current_setting('server_version') AS "Instance Version";
Instance Version
-------------------------------------------------------
Aurora: 13.3.0 Compatible with PostgreSQL: 13.3
```
# aurora\$1volume\$1logical\$1start\$1lsn
Aurora 클러스터 볼륨의 논리적 미리 쓰기 로그(WAL) 스트림에서 레코드의 시작을 식별하는 데 사용되는 로그 시퀀스 번호(LSN)를 반환합니다.
## 구문
```
aurora_volume_logical_start_lsn()
```
## 인수
없음
## 반환 타입
`pg_lsn`
## 사용 노트
이 함수는 주어진 Aurora 클러스터 볼륨의 논리적 WAL 스트림에서 레코드의 시작 부분을 식별합니다. 논리적 복제와 Aurora 고속 복제를 사용하여 메이저 버전 업그레이드를 수행하는 동안 이 함수를 사용하여 스냅샷 또는 데이터베이스 클론이 생성된 LSN을 확인할 수 있습니다. 그런 다음 논리적 복제를 사용하여 LSN 이후에 기록된 최신 데이터를 지속적으로 스트리밍하고 게시자에서 구독자로 변경 내용을 동기화할 수 있습니다.
메이저 버전 업그레이드에 논리적 복제를 사용하는 방법에 대한 자세한 내용은 [논리적 복제를 사용하여 Aurora PostgreSQL에 대한 메이저 버전 업그레이드 수행](AuroraPostgreSQL.MajorVersionUpgrade.md) 섹션을 참조하세요.
이 함수는 다음 Aurora PostgreSQL 버전에서 사용할 수 있습니다.
+ 15.2 이상의 15 버전
+ 14.3 이상의 14 버전
+ 13.6 이상의 13 버전
+ 12.10 이상의 12 버전
+ 11.15 이상의 11 버전
+ 10.20 이상의 10 버전
## 예시
다음 쿼리를 사용하여 로그 시퀀스 번호(LSN)를 얻을 수 있습니다.
```
postgres=> SELECT aurora_volume_logical_start_lsn();
aurora_volume_logical_start_lsn
---------------
0/402E2F0
(1 row)
```
# aurora\$1wait\$1report
이 함수는 일정 기간 동안 대기 이벤트 활동을 표시합니다.
## 구문
```
aurora_wait_report([time])
```
## 인수
*시간(선택 사항)*
시간(초)입니다. 기본값은 10초입니다.
## 반환 타입
다음 열이 있는 SETOF 레코드:
+ type\$1name - 대기 유형 이름
+ event\$1name - 대기 이벤트 이름
+ wait - 대기 횟수
+ wait\$1time - 대기 시간(밀리초)
+ ms\$1per\$1wait - 대기 수당 한 평균 밀리초
+ waits\$1per\$1xact - 트랜잭션 수 하나당 평균 대기
+ ms\$1per\$1wait - 트랜잭션 수당 평균 밀리초
## 사용 노트
이 함수는 PostgreSQL 9.6.6 이상 버전과 호환되는 Aurora PostgreSQL 릴리스 1.1부터 사용할 수 있습니다.
이 함수를 사용하려면 먼저 Aurora PostgreSQL`aurora_stat_utils` 확장을 다음과 같이 생성해야 합니다.
```
=> CREATE extension aurora_stat_utils;
CREATE EXTENSION
```
사용할 수 있는 Aurora PostgreSQL 확장 버전에 대한 자세한 내용은 *Aurora PostgreSQL 릴리스 정보*보의 [Amazon Aurora PostgreSQL 확장 버전](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Extensions.html)을 참조하세요.
이 함수는 aurora\$1stat\$1system\$1waits () 함수와 pg\$1stat\$1database PostgreSQL 통계 뷰에서 얻은 통계 데이터의 두 스냅샷을 비교하여 인스턴스 수준 대기 이벤트를 계산합니다.
`aurora_stat_system_waits()` 및 `pg_stat_database`에 대한 자세한 내용은 *PostgreSQL 설명서*에서 [통계 수집기](https://www.postgresql.org/docs/current/monitoring-stats.html#PG-STAT-DATABASE-VIEW)를 참조하세요.
실행 시 이 함수는 초기 스냅샷을 찍고 지정된 시간(초)을 기다린 다음 두 번째 스냅샷을 찍습니다. 이 함수는 두 스냅샷을 비교하고 차이를 반환합니다. 이 차이는 해당 시간 간격의 인스턴스 활동을 나타냅니다.
라이터 인스턴스에서 함수는 커밋된 트랜잭션 수와 TPS(초당 트랜잭션 수)도 표시합니다. 이 함수는 인스턴스 수준에서 정보를 반환하며 인스턴스의 모든 데이터베이스를 포함합니다.
## 예시
이 예제에서는 aurora\$1wait\$1report 함수를 사용할 수 있도록 aurora\$1stat\$1utils 확장을 만드는 방법을 보여줍니다.
```
=> CREATE extension aurora_stat_utils;
CREATE EXTENSION
```
이 예에서는 10초에 대한 대기 보고서를 확인하는 방법을 보여 줍니다.
```
=> SELECT *
FROM aurora_wait_report();
NOTICE: committed 34 transactions in 10 seconds (tps 3)
type_name | event_name | waits | wait_time | ms_per_wait | waits_per_xact | ms_per_xact
-----------+-------------------+-------+-----------+-------------+----------------+-------------
Client | ClientRead | 26 | 30003.00 | 1153.961 | 0.76 | 882.441
Activity | WalWriterMain | 50 | 10051.32 | 201.026 | 1.47 | 295.627
Timeout | PgSleep | 1 | 10049.52 | 10049.516 | 0.03 | 295.574
Activity | BgWriterHibernate | 1 | 10048.15 | 10048.153 | 0.03 | 295.534
Activity | AutoVacuumMain | 18 | 9941.66 | 552.314 | 0.53 | 292.402
Activity | BgWriterMain | 1 | 201.09 | 201.085 | 0.03 | 5.914
IO | XactSync | 15 | 25.34 | 1.690 | 0.44 | 0.745
IO | RelationMapRead | 12 | 0.54 | 0.045 | 0.35 | 0.016
IO | WALWrite | 84 | 0.21 | 0.002 | 2.47 | 0.006
IO | DataFileExtend | 1 | 0.02 | 0.018 | 0.03 | 0.001
```
이 예에서는 60초에 대한 대기 보고서를 확인하는 방법을 보여 줍니다.
```
=> SELECT *
FROM aurora_wait_report(60);
NOTICE: committed 1544 transactions in 60 seconds (tps 25)
type_name | event_name | waits | wait_time | ms_per_wait | waits_per_xact | ms_per_xact
-----------+------------------------+---------+-----------+-------------+----------------+-------------
Lock | transactionid | 6422 | 477000.53 | 74.276 | 4.16 | 308.938
Client | ClientRead | 8265 | 270752.99 | 32.759 | 5.35 | 175.358
Activity | CheckpointerMain | 1 | 60100.25 | 60100.246 | 0.00 | 38.925
Timeout | PgSleep | 1 | 60098.49 | 60098.493 | 0.00 | 38.924
Activity | WalWriterMain | 296 | 60010.99 | 202.740 | 0.19 | 38.867
Activity | AutoVacuumMain | 107 | 59827.84 | 559.139 | 0.07 | 38.749
Activity | BgWriterMain | 290 | 58821.83 | 202.834 | 0.19 | 38.097
IO | XactSync | 1295 | 55220.13 | 42.641 | 0.84 | 35.764
IO | WALWrite | 6602259 | 47810.94 | 0.007 | 4276.07 | 30.966
Lock | tuple | 473 | 29880.67 | 63.173 | 0.31 | 19.353
LWLock | buffer_mapping | 142 | 3540.13 | 24.930 | 0.09 | 2.293
Activity | BgWriterHibernate | 290 | 1124.15 | 3.876 | 0.19 | 0.728
IO | BufFileRead | 7615 | 618.45 | 0.081 | 4.93 | 0.401
LWLock | buffer_content | 73 | 345.93 | 4.739 | 0.05 | 0.224
LWLock | lock_manager | 62 | 191.44 | 3.088 | 0.04 | 0.124
IO | RelationMapRead | 72 | 5.16 | 0.072 | 0.05 | 0.003
LWLock | ProcArrayLock | 1 | 2.01 | 2.008 | 0.00 | 0.001
IO | ControlFileWriteUpdate | 2 | 0.03 | 0.013 | 0.00 | 0.000
IO | DataFileExtend | 1 | 0.02 | 0.018 | 0.00 | 0.000
IO | ControlFileSyncUpdate | 1 | 0.00 | 0.000 | 0.00 | 0.000
```