Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Referensi fungsi Aurora PostgreSQL
Berikut ini, Anda dapat menemukan daftar fungsi Aurora PostgreSQL yang tersedia untuk klaster DB Aurora Anda yang menjalankan mesin DB Aurora Edisi Kompatibel PostgreSQL. Fungsi Aurora PostgreSQL ini merupakan tambahan dari fungsi PostgreSQL standar. Untuk informasi selengkapnya tentang fungsi PostgreSQL standar, lihat [PostgreSQL–Fungsi dan Operator](https://www.postgresql.org/docs/current/functions.html).
## Ikhtisar
Anda dapat menggunakan fungsi berikut untuk instans DB Amazon RDS yang menjalankan 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
Melaporkan nama instans DB yang terhubung dengan Anda.
## Sintaksis
```
aurora_db_instance_identifier()
```
## Argumen
Tidak ada
## Jenis pengembalian
String VARCHAR
## Catatan penggunaan
Fungsi ini menampilkan nama instans DB klaster Aurora Edisi Kompatibel PostgreSQL untuk klien basis data atau koneksi aplikasi Anda.
Fungsi ini tersedia dimulai dengan rilis Aurora PostgreSQL versi 13.7, 12.11, 11.16, dan 10.21 serta untuk semua versi lain yang lebih baru.
## Contoh
Contoh berikut menampilkan hasil pemanggilan fungsi `aurora_db_instance_identifier`.
```
=> SELECT aurora_db_instance_identifier();
aurora_db_instance_identifier
-------------------------------
test-my-instance-name
```
Anda dapat menggabungkan hasil fungsi ini dengan fungsi `aurora_replica_status` untuk mendapatkan detail tentang instans DB untuk koneksi Anda. [aurora\$1replica\$1status](aurora_replica_status.md) sendiri tidak memberikan tampilan instans DB mana yang Anda gunakan. Contoh kode berikut ini menunjukkan caranya.
```
=> 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
Menampilkan status pengelola cache klaster.
## Sintaksis
```
aurora_ccm_status()
```
## Argumen
Tidak ada.
## Jenis pengembalian
Catatan SETOF dengan kolom berikut:
+ `buffers_sent_last_minute` – Jumlah buffer yang dikirim ke pembaca yang ditunjuk dalam beberapa menit terakhir.
+ `buffers_found_last_minute` – Jumlah buffer yang sering diakses diidentifikasi selama beberapa menit terakhir.
+ `buffers_sent_last_scan` – Jumlah buffer yang dikirim ke pembaca yang ditunjuk selama pemindaian lengkap cache buffer.
+ `buffers_found_last_scan` – Jumlah buffer yang sering diakses yang dikirim selama pemindaian lengkap cache buffer. Buffer yang sudah di-cache di pembaca yang ditunjuk tidak akan dikirimkan.
+ `buffers_sent_current_scan` – Jumlah buffer yang dikirim selama pemindaian saat ini.
+ `buffers_found_current_scan` – Jumlah buffer yang sering diakses yang diidentifikasi dalam pemindaian saat ini.
+ `current_scan_progress` – Jumlah buffer yang dikunjungi sejauh ini selama pemindaian saat ini.
## Catatan penggunaan
Anda dapat menggunakan fungsi ini untuk memeriksa dan memantau fitur manajemen cache klaster (CCM). Fungsi ini hanya berfungsi jika CCM aktif di klaster DB Aurora PostgreSQL Anda. Untuk menggunakan fungsi ini, Anda menghubungkan ke instans Write DB di klaster Aurora PostgreSQL Anda.
Anda mengaktifkan CCM untuk klaster DB Aurora PostgreSQL dengan mengatur `apg_ccm_enabled` ke 1 di grup parameter klaster DB kustom klaster. Untuk mempelajari caranya, lihat [Mengonfigurasi manajemen cache klaster](AuroraPostgreSQL.cluster-cache-mgmt.md#AuroraPostgreSQL.cluster-cache-mgmt.Configure).
Manajemen cache klaster aktif pada klaster DB Aurora PostgreSQL ketika klaster memiliki instans Pembaca Aurora yang dikonfigurasi sebagai berikut:
+ Instans Pembaca Aurora menggunakan jenis dan ukuran kelas instans DB yang sama dengan instans Penulis klaster.
+ Instans Pembaca Aurora dikonfigurasi sebagai Tier-0 untuk klaster. Jika klaster memiliki lebih dari satu Pembaca, ini adalah satu-satunya Pembaca Tier-0.
Mengatur lebih dari satu Pembaca ke Tier-0 menonaktifkan CCM. Ketika CCM dinonaktifkan, memanggil fungsi ini mengembalikan pesan kesalahan berikut:
```
ERROR: Cluster Cache Manager is disabled
```
Anda juga dapat menggunakan ekstensi pg\$1buffercache PostgreSQL untuk menganalisis cache buffer. Untuk informasi selengkapnya, lihat [pg\$1buffercache](https://www.postgresql.org/docs/current/pgbuffercache.html) di dokumentasi PostgreSQL.
Untuk informasi selengkapnya, lihat [Pengantar manajemen cache klaster Aurora PostgreSQL](https://aws.amazon.com/blogs/database/introduction-to-aurora-postgresql-cluster-cache-management/).
## Contoh
Contoh berikut menampilkan hasil pemanggilan fungsi `aurora_ccm_status`. Contoh pertama ini menunjukkan statistik 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
```
Untuk detail yang lebih lengkap, Anda dapat menggunakan tampilan yang diperluas, seperti yang ditunjukkan berikut:
```
\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
```
Contoh ini menunjukkan cara memeriksa tingkat hangat dan persentase hangat.
```
=> 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
Menampilkan status semua instans Aurora, termasuk replika dalam klaster DB global Aurora.
## Sintaksis
```
aurora_global_db_instance_status()
```
## Argumen
Tidak ada
## Jenis pengembalian
Catatan SETOF dengan kolom berikut:
+ `server_id` – Pengidentifikasi instans DB.
+ `session_id` – Pengidentifikasi unik untuk sesi saat ini. Nilai `MASTER_SESSION_ID` mengidentifikasi instans DB Penulis (primer).
+ `aws_region`— Wilayah AWS Di mana instans DB global ini berjalan. Untuk daftar Wilayah, lihat [Ketersediaan wilayah](Concepts.RegionsAndAvailabilityZones.md#Aurora.Overview.Availability).
+ `durable_lsn` – Nomor urutan log (LSN) dibuat durabel di penyimpanan. Nomor urutan log (LSN) adalah nomor urut unik yang mengidentifikasi catatan dalam log transaksi database. LSNs dipesan sedemikian rupa sehingga LSN yang lebih besar mewakili transaksi selanjutnya.
+ `highest_lsn_rcvd` – LSN tertinggi yang diterima oleh instans DB dari instans DB penulis.
+ `feedback_epoch` – Masa yang digunakan instans DB saat menghasilkan informasi hot standby. *Hot standby* adalah instans DB yang mendukung koneksi dan kueri saat DB primer berada dalam mode pemulihan atau mode siaga. Informasi hot standby mencakup masa (titik waktu) dan detail lain tentang instans DB yang digunakan sebagai hot standby. Untuk informasi selengkapnya, lihat [Hot standby](https://www.postgresql.org/docs/current/hot-standby.html) di dokumentasi PostgreSQL.
+ `feedback_xmin` – ID transaksi aktif minimum (terlawas) yang digunakan oleh instans DB.
+ `oldest_read_view_lsn` – LSN terlawas yang digunakan oleh instans DB untuk membaca dari penyimpanan.
+ `visibility_lag_in_msec` – Seberapa jauh instans DB ini tetap tertinggal di belakang instans DB penulis dalam milidetik.
## Catatan penggunaan
Fungsi ini menunjukkan statistik replikasi untuk klaster DB Aurora. Untuk setiap instans DB Aurora PostgreSQL di klaster, fungsi menunjukkan barisan data yang menyertakan replika lintas Wilayah dalam konfigurasi basis data global.
Anda dapat menjalankan fungsi ini dari instans apa pun di klaster DB Aurora PostgreSQL atau basis data global Aurora PostgreSQL. Fungsi mengembalikan detail tentang lag untuk semua instans replika.
Untuk mempelajari selengkapnya tentang pemantauan lag menggunakan fungsi ini (`aurora_global_db_instance_status`) atau dengan menggunakan `aurora_global_db_status`, lihat [Memantau basis data global berbasis Aurora PostgreSQL](aurora-global-database-monitoring.md#aurora-global-database-monitoring.postgres).
Untuk informasi selengkapnya tentang basis data global Aurora, lihat [Ikhtisar Database Global Amazon Aurora](aurora-global-database.md#aurora-global-database-overview).
[Untuk memulai dengan database global Aurora, lihat [Memulai dengan Amazon Aurora Global Database](aurora-global-database-getting-started.md) atau lihat Amazon Aurora. FAQs](https://aws.amazon.com/rds/aurora/faqs/)
## Contoh
Contoh ini menunjukkan statistik instans lintas Wilayah.
```
=> 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
```
Contoh ini menunjukkan cara memeriksa lag replika global dalam milidetik.
```
=> 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
```
Contoh ini menunjukkan cara memeriksa min, max dan rata-rata lag per Wilayah AWS dari konfigurasi database 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
Menampilkan informasi tentang berbagai aspek lag basis data global Aurora, khususnya, lag penyimpanan Aurora yang mendasarinya (disebut lag daya tahan) dan lag antara sasaran titik pemulihan (RPO).
## Sintaksis
```
aurora_global_db_status()
```
## Argumen
Tidak ada.
## Jenis pengembalian
Catatan SETOF dengan kolom berikut:
+ `aws_region`— Di Wilayah AWS mana cluster DB ini berada. Untuk daftar lengkap Wilayah AWS berdasarkan mesin, lihat[Wilayah dan Zona Ketersediaan](Concepts.RegionsAndAvailabilityZones.md).
+ `highest_lsn_written` – nomor urutan log (LSN) tertinggi yang saat ini ada di klaster DB ini. Nomor urutan log (LSN) adalah nomor urut unik yang mengidentifikasi catatan dalam log transaksi database. LSNs dipesan sedemikian rupa sehingga LSN yang lebih besar mewakili transaksi selanjutnya.
+ `durability_lag_in_msec` – Perbedaan nilai stempel waktu antara `highest_lsn_written` di klaster DB sekunder dan `highest_lsn_written` klaster DB primer. Nilai -1 mengidentifikasi klaster DB primer dari basis data global Aurora.
+ `rpo_lag_in_msec` – Lag sasaran titik pemulihan (RPO). Lag RPO adalah waktu yang dibutuhkan COMMIT transaksi pengguna terbaru untuk disimpan di klaster DB sekunder setelah disimpan di klaster DB primer dari basis data global Aurora. Nilai -1 menunjukkan klaster DB primer (dan dengan demikian, lag tidak relevan).
Secara sederhana, metrik ini menghitung tujuan titik pemulihan untuk setiap klaster DB Aurora PostgreSQL di basis data global Aurora, yaitu, berapa banyak data yang mungkin hilang jika ada pemadaman. Seperti halnya lag, RPO diukur dalam waktu.
+ `last_lag_calculation_time` – Stempel waktu yang menentukan kapan nilai terakhir dihitung untuk `durability_lag_in_msec` dan `rpo_lag_in_msec`. Nilai waktu seperti `1970-01-01 00:00:00+00` berarti ini adalah klaster DB primer.
+ `feedback_epoch` – Masa yang digunakan klaster DB sekunder saat menghasilkan informasi hot standby. *Hot standby* adalah instans DB yang mendukung koneksi dan kueri saat DB primer berada dalam mode pemulihan atau mode siaga. Informasi hot standby mencakup masa (titik waktu) dan detail lain tentang instans DB yang digunakan sebagai hot standby. Untuk informasi selengkapnya, lihat [Hot standby](https://www.postgresql.org/docs/current/hot-standby.html) di dokumentasi PostgreSQL.
+ `feedback_xmin` – ID transaksi aktif minimum (terlawas) yang digunakan oleh klaster DB sekunder.
## Catatan penggunaan
Semua versi Aurora PostgreSQL yang tersedia saat ini mendukung fungsi ini. Fungsi ini menunjukkan statistik replikasi untuk basis data global Aurora. Hal ini menampilkan satu baris untuk setiap klaster DB dalam basis data global Aurora PostgreSQL. Anda dapat menjalankan fungsi ini dari instans apa pun di basis data global Aurora PostgreSQL.
Untuk mengevaluasi lag replikasi basis data global Aurora, yang merupakan lag data yang terlihat, lihat [aurora\$1global\$1db\$1instance\$1status](aurora_global_db_instance_status.md).
Untuk mempelajari selengkapnya tentang menggunakan `aurora_global_db_status` dan `aurora_global_db_instance_status` memantau lag basis data global Aurora, lihat [Memantau basis data global berbasis Aurora PostgreSQL](aurora-global-database-monitoring.md#aurora-global-database-monitoring.postgres). Untuk informasi selengkapnya tentang basis data global Aurora, lihat [Ikhtisar Database Global Amazon Aurora](aurora-global-database.md#aurora-global-database-overview).
## Contoh
Contoh ini menunjukkan cara menampilkan statistik penyimpanan lintas wilayah.
```
=> 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
Daftar semua fungsi default Aurora PostgreSQL yang tersedia, bersama dengan deskripsi singkat dan detail fungsi.
## Sintaksis
```
aurora_list_builtins()
```
## Argumen
Tidak ada
## Jenis pengembalian
Catatan SETOF
## Contoh
Contoh berikut menampilkan hasil dari pemanggilan fungsi `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
Menampilkan status semua simpul pembaca Aurora PostgreSQL.
## Sintaksis
```
aurora_replica_status()
```
## Argumen
Tidak ada
## Jenis pengembalian
Catatan SETOF dengan kolom berikut:
+ `server_id` – ID instans DB (pengidentifikasi).
+ `session_id` – Pengidentifikasi unik untuk sesi saat ini, dikembalikan untuk instans utama dan instans pembaca sebagai berikut:
+ Untuk contoh instans primer, `session_id` selalu ``MASTER_SESSION_ID’`.
+ Untuk instans pembaca, `session_id` selalu merupakan `UUID` (pengidentifikasi unik universal) dari instans pembaca.
+ `durable_lsn` – Nomor urutan log (LSN) yang disimpan di penyimpanan.
+ Untuk volume primer, volume primer LSN (VDL) durabel yang saat ini berlaku.
+ Untuk setiap volume sekunder, VDL primer yang sekundernya telah berhasil diterapkan.
**catatan**
Nomor urutan log (LSN) adalah nomor urut unik yang mengidentifikasi catatan dalam log transaksi database. LSNs dipesan sedemikian rupa sehingga LSN yang lebih besar mewakili transaksi yang terjadi kemudian dalam urutan.
+ `highest_lsn_rcvd` – LSN tertinggi (terbaru) yang diterima oleh instans DB dari instans DB penulis.
+ `current_read_lsn` – LSN dari snapshot terbaru yang telah diterapkan untuk semua pembaca.
+ `cur_replay_latency_in_usec` – Jumlah mikrodetik yang diharapkan untuk memutar ulang log di sekunder.
+ `active_txns` – Jumlah transaksi yang aktif saat ini.
+ `is_current` – Tidak digunakan.
+ `last_transport_error` – Kode kesalahan replikasi terakhir.
+ `last_error_timestamp` – Stempel waktu kesalahan replikasi terakhir.
+ `last_update_timestamp` – Stempel waktu pembaruan terakhir ke status replika. Dari Aurora PostgreSQL 13.9, nilai `last_update_timestamp` untuk instans DB yang terhubung dengan Anda diatur ke `NULL`.
+ `feedback_xmin` – Hot standby feedback\$1xmin dari replika. ID transaksi aktif minimum (terlawas) yang digunakan oleh instans DB.
+ `feedback_epoch` – Masa yang digunakan instans DB saat menghasilkan informasi hot standby.
+ `replica_lag_in_msec`— Waktu instance pembaca tertinggal dari instance penulis, dalam milidetik.
+ `log_stream_speed_in_kib_per_second` – Throughput log stream dalam kilobyte per detik.
+ `log_buffer_sequence_number` – Nomor urutan buffer log.
+ `oldest_read_view_trx_id` – Tidak digunakan.
+ `oldest_read_view_lsn` – LSN terlawas yang digunakan oleh instans DB untuk membaca dari penyimpanan.
+ `pending_read_ios` – Pembacaan halaman luar biasa yang masih tertunda pada replika.
+ `read_ios` – Jumlah pembacaan halaman pada replika.
+ `iops` – Tidak digunakan.
+ `cpu`— Penggunaan CPU dari Aurora Storage Daemon untuk setiap node di cluster. Untuk informasi tentang penggunaan CPU oleh instans, lihat[Metrik tingkat instans untuk Amazon Aurora](Aurora.AuroraMonitoring.Metrics.md#Aurora.AuroraMySQL.Monitoring.Metrics.instances).
## Catatan penggunaan
Semua versi Aurora PostgreSQL yang tersedia saat ini mendukung fungsi ini. Fungsi `aurora_replica_status` mengembalikan nilai dari manajer status replika klaster DB Aurora PostgreSQL. Anda dapat menggunakan fungsi ini untuk mendapatkan informasi tentang status replikasi pada klaster DB PostgreSQL Aurora Anda, termasuk metrik untuk semua instans DB di klaster DB Aurora Anda. Misalnya, Anda dapat melakukan hal berikut:
+ **Mendapatkan informasi tentang jenis instans (penulis, pembaca) di klaster DB Aurora PostgreSQL** – Anda dapat memperoleh informasi ini dengan memeriksa nilai-nilai kolom berikut:
+ `server_id` – Berisi nama instans yang Anda tentukan saat membuat instans. Dalam beberapa kasus, seperti untuk instans primer (penulis), nama biasanya dibuat untuk Anda dengan menambahkan *-instance-1* ke nama yang Anda buat untuk klaster DB Aurora PostgreSQL Anda.
+ `session_id` – Bidang `session_id` menunjukkan apakah instans adalah pembaca atau penulis. Untuk instans penulis, `session_id` selalu diatur ke `"MASTER_SESSION_ID"`. Untuk instans pembaca, `session_id` diatur ke `UUID` pembaca tertentu.
+ **Mendiagnosis masalah replikasi umum, seperti lag replika** – Lag replica adalah waktu dalam milidetik cache halaman dari instans pembaca berada di belakang instans penulis. Lag ini terjadi karena klaster Aurora menggunakan replikasi asinkron, seperti yang dijelaskan dalam [Replikasi dengan Amazon Aurora](Aurora.Replication.md). Lagi ini ditampilkan di kolom `replica_lag_in_msec` dalam hasil yang dikembalikan oleh fungsi ini. Lag juga dapat terjadi ketika kueri dibatalkan karena konflik dengan pemulihan pada server siaga. Anda dapat memeriksa `pg_stat_database_conflicts()` untuk memverifikasi bahwa konflik seperti itu menyebabkan lag replika (atau tidak). Untuk informasi selengkapnya, lihat [The Statistics Collector](https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-DATABASE-CONFLICTS-VIEW) di *Dokumentasi PostgreSQL*. Untuk mempelajari lebih lanjut tentang ketersediaan dan replikasi tinggi, lihat [Amazon FAQs](https://aws.amazon.com/rds/aurora/faqs/#High_Availability_and_Replication) Aurora.
Amazon CloudWatch menyimpan `replica_lag_in_msec` hasil dari waktu ke waktu, sebagai `AuroraReplicaLag` metrik. Untuk informasi tentang penggunaan CloudWatch metrik untuk Aurora, lihat [Memantau Amazon Aurora dengan Amazon CloudWatch](monitoring-cloudwatch.md)
Untuk mempelajari selengkapnya tentang pemecahan masalah replika dan pemulaian ulang pembacaan Aurora, lihat [Mengapa replika pembacaan Amazon Aurora saya tertinggal dan memulai ulang?](https://aws.amazon.com/premiumsupport/knowledge-center/aurora-read-replica-restart/) di [Pusat AWS Dukungan](https://console.aws.amazon.com/support/home#/).
## Contoh
Contoh berikut menunjukkan cara mendapatkan status replikasi dari semua instans di klaster DB Aurora PostgreSQL:
```
=> SELECT *
FROM aurora_replica_status();
```
Contoh berikut menunjukkan contoh instans penulis di klaster DB 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
```
Contoh berikut mencantumkan semua instans pembaca dalam sebuah klaster:
```
=> 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)
```
Contoh berikut mencantumkan semua instans, seberapa jauh setiap instans tertinggal dari penulis, dan berapa lama sejak pembaruan terakhir:
```
=> 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
Mengembalikan satu baris per proses server, menampilkan informasi yang terkait dengan aktivitas saat ini dari proses itu.
## Sintaks
```
aurora_stat_activity();
```
## Argumen
Tidak ada
## Jenis pengembalian
Mengembalikan satu baris per proses server. Selain `pg_stat_activity` kolom, bidang berikut ditambahkan:
+ planid - pengidentifikasi rencana
## Catatan penggunaan
Tampilan tambahan untuk `pg_stat_activity` mengembalikan kolom yang sama dengan `plan_id` kolom tambahan yang menunjukkan rencana eksekusi kueri saat ini.
`aurora_compute_plan_id`harus diaktifkan agar tampilan mengembalikan plan\$1id.
Fungsi ini tersedia dari Aurora PostgreSQL versi 14.10, 15.5, dan untuk semua versi lain yang lebih baru.
## Contoh
Contoh kueri di bawah ini menggabungkan beban teratas dengan query\$1id dan 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)
```
Jika rencana yang digunakan untuk query\$1id berubah, plan\$1id baru akan dilaporkan oleh aurora\$1stat\$1activity.
```
count | query_id | plan_id
-------+----------------------+-------------
10 | -5471422286312252535 | 1602979607
1 | -6907107586630739258 | -1809935983
1 | -2446282393000597155 | -207532066
(3 rows)
```
# aurora\$1stat\$1backend\$1waits
Menampilkan statistik untuk aktivitas menunggu untuk proses backend tertentu.
## Sintaksis
```
aurora_stat_backend_waits(pid)
```
## Argumen
`pid` – ID untuk proses backend. Anda dapat memperoleh proses IDs dengan menggunakan `pg_stat_activity` tampilan.
## Jenis pengembalian
Catatan SETOF dengan kolom berikut:
+ `type_id` – Angka yang menunjukkan jenis peristiwa tunggu, seperti `1` untuk kunci ringan (`LWLock`), `3` untuk kunci, atau `6` untuk sesi klien, untuk menyebutkan beberapa contoh. Nilai-nilai ini menjadi bermakna ketika Anda menggabungkan hasil fungsi ini dengan kolom dari fungsi `aurora_stat_wait_type`, seperti yang ditunjukkan dalam [Contoh](#aurora_stat_backend_waits-examples).
+ `event_id` – Nomor pengidentifikasi untuk peristiwa tunggu. Gabungkan nilai ini dengan kolom dari `aurora_stat_wait_event` untuk mendapatkan nama peristiwa yang bermakna.
+ `waits` – Hitungan jumlah tunggu yang terakumulasi untuk ID proses yang ditentukan.
+ `wait_time` – Waktu tunggu dalam milidetik.
## Catatan penggunaan
Anda dapat menggunakan fungsi ini untuk menganalisis peristiwa tunggu backend (sesi) tertentu yang terjadi sejak koneksi dibuka. Untuk mendapatkan informasi yang lebih bermakna tentang nama dan jenis peristiwa tunggu, Anda dapat menggabungkan fungsi `aurora_stat_wait_type` dan `aurora_stat_wait_event` ini, dengan menggunakan JOIN seperti yang ditunjukkan dalam contoh.
## Contoh
Contoh ini menunjukkan semua tunggu, jenis, dan nama peristiwa untuk proses backend 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
```
Contoh ini menunjukkan jenis tunggu saat ini dan kumulatif serta peristiwa tunggu untuk semua sesi aktif (`pg_stat_activity state <> 'idle'`) (tetapi tanpa sesi saat ini yang menjalankan fungsi (`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
```
Contoh ini menunjukkan jenis tunggu kumulatif saat ini dan tiga teratas (3) serta peristiwa tunggu kumulatif untuk semua sesi aktif (`pg_stat_activity state <> 'idle'`) tidak termasuk sesi saat ini (`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` adalah tampilan statistik yang menampilkan informasi tentang penulisan cache Optimized Reads.
## Sintaksis
```
aurora_stat_bgwriter()
```
## Argumen
Tidak ada
## Jenis pengembalian
Catatan SETOF dengan semua kolom `pg_stat_bgwriter` dan kolom tambahan berikut. Untuk informasi selengkapnya tentang kolom `pg_stat_bgwriter`, lihat [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).
Anda dapat mengatur ulang statistik untuk fungsi ini menggunakan `pg_stat_reset_shared("bgwriter")`.
+ `orcache_blks_written` – Jumlah total blok data cache pembacaan yang dioptimalkan ditulis.
+ `orcache_blk_write_time` – Jika `track_io_timing` diaktifkan, fungsi ini melacak total waktu yang dihabiskan untuk menulis blok file data cache yang dioptimalkan, dalam milidetik. Untuk informasi selengkapnya, lihat [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
## Catatan penggunaan
Fungsi ini tersedia di versi Aurora PostgreSQL berikut:
+ Versi 15.4 dan versi 15 yang lebih tinggi
+ Versi 14.9 dan versi 14 yang lebih tinggi
## Contoh
```
=> select * from aurora_stat_bgwriter();
-[ RECORD 1 ]-----------------+-----------
orcache_blks_written | 246522
orcache_blk_write_time | 339276.404
```
# aurora\$1stat\$1database
Fungsi ini membawa semua kolom pg\$1stat\$1database dan menambahkan kolom baru pada akhirnya.
## Sintaksis
```
aurora_stat_database()
```
## Argumen
Tidak ada
## Jenis pengembalian
Catatan SETOF dengan semua kolom `pg_stat_database` dan kolom tambahan berikut. Untuk informasi selengkapnya tentang kolom `pg_stat_database`, lihat [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` – Jumlah total blok bersama yang dibaca dari penyimpanan aurora dalam basis data ini.
+ `orcache_blks_hit` – Jumlah total hit cache pembacaan yang dioptimalkan dalam basis data ini.
+ `local_blks_read` – Jumlah total blok lokal yang dibaca dalam basis data ini.
+ `storage_blk_read_time` – Jika `track_io_timing` diaktifkan, total waktu yang dihabiskan untuk membaca blok file data dari penyimpanan aurora dilacak dalam milidetik. Jika tidak, nilainya nol. Untuk informasi selengkapnya, lihat [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
+ `local_blk_read_time` – Jika `track_io_timing` diaktifkan, total waktu yang dihabiskan untuk membaca blok file data lokal dilacak dalam milidetik. Jika tidak, nilainya nol. Untuk informasi selengkapnya, lihat [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
+ `orcache_blk_read_time` – Jika `track_io_timing` diaktifkan, total waktu yang dihabiskan untuk membaca blok file data dari cache pembacaan yang dioptimalkan dilacak dalam milidetik. Jika tidak, nilainya nol. Untuk informasi selengkapnya, lihat [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
**catatan**
Nilai `blks_read` adalah jumlah dari `storage_blks_read`, `orcache_blks_hit`, dan `local_blks_read`.
Nilai `blk_read_time` adalah jumlah dari `storage_blk_read_time`, `orcache_blk_read_time`, dan `local_blk_read_time`.
## Catatan penggunaan
Fungsi ini tersedia di versi Aurora PostgreSQL berikut:
+ Versi 15.4 dan versi 15 yang lebih tinggi
+ Versi 14.9 dan versi 14 yang lebih tinggi
## Contoh
Contoh berikut menunjukkan bagaimana fungsi ini membawa semua kolom `pg_stat_database` dan menambahkan 6 kolom baru pada akhirnya:
```
=> 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
Melaporkan aktivitas kumulatif untuk setiap jenis operasi bahasa manipulasi data (DML) pada basis data dalam klaster Aurora PostgreSQL.
## Sintaksis
```
aurora_stat_dml_activity(database_oid)
```
## Argumen
*database\$1oid*
ID Objek (OID) dari basis data di klaster Aurora PostgreSQL.
## Jenis pengembalian
Catatan SETOF
## Catatan penggunaan
Fungsi `aurora_stat_dml_activity` hanya tersedia dengan Aurora PostgreSQL rilis 3.1 yang kompatibel dengan mesin PostgreSQL 11.6 dan yang lebih baru.
Gunakan fungsi ini pada klaster Aurora PostgreSQL dengan sejumlah besar basis data untuk mengidentifikasi basis data mana yang memiliki aktivitas DML lebih banyak atau lebih lambat, atau keduanya.
Fungsi `aurora_stat_dml_activity` mengembalikan berapa kali operasi dijalankan dan latensi kumulatif dalam mikrodetik untuk operasi SELECT, INSERT, UPDATE, dan DELETE. Laporan ini hanya mencakup operasi DML yang berhasil.
Anda dapat mengatur ulang statistik ini dengan menggunakan fungsi akses statistik PostgreSQL `pg_stat_reset`. Anda dapat memeriksa kapan terakhir kali statistik ini diatur ulang dengan menggunakan fungsi `pg_stat_get_db_stat_reset_time`. Untuk informasi selengkapnya tentang fungsi akses statistik PostgreSQL, lihat [The Statistics Collector](https://www.postgresql.org/docs/9.1/monitoring-stats.html) dalam dokumentasi PostgreSQL.
## Contoh
Contoh berikut menunjukkan cara melaporkan statistik aktivitas DML untuk basis data yang terhubung.
```
––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
```
Contoh berikut menunjukkan statistik aktivitas DML untuk semua basis data di klaster Aurora PostgreSQL. Klaster ini memiliki dua basis data, `postgres` dan `mydb`. Daftar yang dipisahkan koma sesuai dengan bidang `select_count`, `select_latency_microsecs`, `insert_count`, `insert_latency_microsecs`, `update_count`, `update_latency_microsecs`, `delete_count`, dan `delete_latency_microsecs`.
Aurora PostgreSQL membuat dan menggunakan basis data sistem bernama `rdsadmin` untuk mendukung operasi administratif seperti pencadangan, pemulihan, pemeriksaan kondisi, replikasi, dan sebagainya. Operasi DML ini tidak berdampak pada klaster Aurora PostgreSQL Anda.
```
=> 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)
```
Contoh berikut menunjukkan statistik aktivitas DML untuk semua basis data, diatur dalam kolom untuk keterbacaan yang lebih baik.
```
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
```
Contoh berikut menunjukkan latensi kumulatif rata-rata (latensi kumulatif dibagi dengan hitungan) untuk setiap operasi DML untuk basis data dengan 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
Mendapatkan latensi commit kumulatif dalam mikrodetik untuk basis data Aurora PostgreSQL. *Latensi commit* diukur sebagai waktu antara saat klien mengirimkan permintaan commit dan saat menerima pengakuan commit.
## Sintaksis
```
aurora_stat_get_db_commit_latency(database_oid)
```
## Argumen
*database\$1oid*
ID Objek (OID) dari basis data Aurora PostgreSQL.
## Jenis pengembalian
Catatan SETOF
## Catatan penggunaan
Amazon CloudWatch menggunakan fungsi ini untuk menghitung latensi komit rata-rata. Untuk informasi selengkapnya tentang CloudWatch metrik Amazon dan cara memecahkan masalah latensi komit tinggi, lihat [Melihat metrik di konsol Amazon RDS](USER_Monitoring.md) serta [Membuat keputusan yang lebih baik tentang Amazon RDS dengan metrik Amazon](https://aws.amazon.com/blogs/database/making-better-decisions-about-amazon-rds-with-amazon-cloudwatch-metrics/). CloudWatch
Anda dapat mengatur ulang statistik ini dengan menggunakan fungsi akses statistik PostgreSQL `pg_stat_reset`. Anda dapat memeriksa kapan terakhir kali statistik ini diatur ulang dengan menggunakan fungsi `pg_stat_get_db_stat_reset_time`. Untuk informasi selengkapnya tentang fungsi akses statistik PostgreSQL, lihat [The Statistics Collector](https://www.postgresql.org/docs/9.1/monitoring-stats.html) dalam dokumentasi PostgreSQL.
## Contoh
Contoh berikut mendapatkan latensi commit kumulatif untuk setiap basis data di klaster `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
```
Contoh berikut mendapatkan latensi commit kumulatif untuk basis data yang terhubung saat ini. Sebelum memanggil fungsi `aurora_stat_get_db_commit_latency`, contoh pertama menggunakan `\gset` guna mendefinisikan variabel untuk argumen `oid` dan menetapkan nilainya dari basis data yang terhubung.
```
––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
```
Contoh berikut mendapatkan latensi commit kumulatif untuk basis data `mydb` di klaster `pg_database`. Setelah itu, contoh tersebut mengatur ulang statistik ini dengan menggunakan fungsi `pg_stat_reset` dan menampilkan hasilnya. Terakhir, contoh tersebut menggunakan fungsi `pg_stat_get_db_stat_reset_time` untuk memeriksa kapan terakhir kali statistik diatur ulang.
```
=> 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
Menampilkan penggunaan cache log write-ahead (WAL) per slot.
## Sintaksis
```
SELECT * FROM aurora_stat_logical_wal_cache()
```
## Argumen
Tidak ada
## Jenis pengembalian
Catatan SETOF dengan kolom berikut:
+ `name` – Nama slot replikasi.
+ `active_pid` – ID proses walsender.
+ `cache_hit` – Jumlah total hit cache wal sejak atur ulang terakhir.
+ `cache_miss` – Jumlah total hilang cache wal sejak atur ulang terakhir.
+ `blks_read` – Jumlah total permintaan baca cache wal.
+ `hit_rate` – Laju hit cache WAL (cache\$1hit/blks\$1read).
+ `last_reset_timestamp` – Terakhir kali penghitung diatur ulang.
## Catatan penggunaan
Fungsi ini tersedia untuk versi Aurora PostgreSQL berikut.
+ 15.2 dan semua versi yang lebih tinggi
+ 14.7 dan versi yang lebih tinggi
+ Versi 13.8 dan versi yang lebih tinggi
+ Versi 12.12 dan versi yang lebih tinggi
+ Versi 11.17 dan versi yang lebih tinggi
## Contoh
Contoh berikut menampilkan dua slot replikasi dengan hanya satu yang aktif. Fungsi `aurora_stat_logical_wal_cache`.
```
=> 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
Melaporkan penggunaan konteks memori untuk setiap proses PostgreSQL.
## Sintaksis
```
aurora_stat_memctx_usage()
```
## Argumen
Tidak ada
## Jenis pengembalian
Catatan SETOF dengan kolom berikut:
+ `pid` – ID dari proses.
+ `name` – Nama konteks memori.
+ `allocated` – Jumlah byte yang diperoleh dari subsistem memori yang mendasarinya oleh konteks memori.
+ `used` – Jumlah byte yang dijalankan untuk klien dari konteks memori.
+ `instances` – Hitungan konteks yang ada saat ini dari jenis ini.
## Catatan penggunaan
Fungsi ini menampilkan penggunaan konteks memori untuk setiap proses PostgreSQL. Beberapa proses diberi label `anonymous`. Proses tidak diekspos karena mengandung kata kunci yang dibatasi.
Fungsi ini tersedia mulai dengan versi Aurora PostgreSQL berikut:
+ Versi 15.3 dan versi 15 yang lebih tinggi
+ 14.8 dan versi 14 yang lebih tinggi
+ 13.11 dan versi 13 yang lebih tinggi
+ 12.15 dan versi 12 yang lebih tinggi
+ Versi 11.20 dan versi 11 yang lebih tinggi
## Contoh
Contoh berikut menampilkan hasil pemanggilan fungsi `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)
```
Beberapa kata kunci terbatas akan disembunyikan dan output akan terlihat sebagai berikut:
```
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
Fungsi ini menunjukkan statistik cache berjenjang.
## Sintaksis
```
aurora_stat_optimized_reads_cache()
```
## Argumen
Tidak ada
## Jenis pengembalian
Catatan SETOF dengan kolom berikut:
+ `total_size` – Total ukuran cache bacaan yang dioptimalkan.
+ `used_size` – Ukuran halaman yang digunakan dalam cache bacaan yang dioptimalkan.
## Catatan penggunaan
Fungsi ini tersedia di versi Aurora PostgreSQL berikut:
+ Versi 15.4 dan versi 15 yang lebih tinggi
+ Versi 14.9 dan versi 14 yang lebih tinggi
## Contoh
Contoh berikut menampilkan output pada contoh instans 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
Mengembalikan baris untuk setiap rencana eksekusi dilacak.
## Sintaks
```
aurora_stat_plans(
showtext
)
```
## Argumen
+ showtext - Tampilkan kueri dan rencana teks. Nilai yang valid adalah NULL, benar atau salah. True akan menampilkan kueri dan rencana teks.
## Jenis pengembalian
Mengembalikan baris untuk setiap rencana dilacak yang berisi semua kolom dari `aurora_stat_statements` dan kolom tambahan berikut.
+ planid - pengidentifikasi rencana
+ explain\$1plan - jelaskan teks rencana
+ plan\$1type:
+ `no plan`- tidak ada rencana yang ditangkap
+ `estimate`- rencana ditangkap dengan perkiraan biaya
+ `actual`- rencana ditangkap dengan EXPLORE ANALYSIS
+ plan\$1captured\$1time — terakhir kali rencana ditangkap
## Catatan penggunaan
`aurora_compute_plan_id`harus diaktifkan dan `pg_stat_statements` harus dalam `shared_preload_libraries` agar rencana dilacak.
Jumlah paket yang tersedia dikendalikan oleh nilai yang ditetapkan dalam `pg_stat_statements.max` parameter. Saat `aurora_compute_plan_id` diaktifkan, Anda dapat melacak paket hingga nilai yang ditentukan ini di`aurora_stat_plans`.
Fungsi ini tersedia dari Aurora PostgreSQL versi 14.10, 15.5, dan untuk semua versi lain yang lebih baru.
## Contoh
Dalam contoh di bawah ini, dua rencana yang untuk pengidentifikasi kueri -5471422286312252535 ditangkap dan statistik pernyataan dilacak oleh 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
Mengatur ulang penghitung untuk cache wal logis.
## Sintaksis
Cara mengatur ulang slot tertentu
```
SELECT * FROM aurora_stat_reset_wal_cache('slot_name')
```
Cara mengatur ulang semua slot
```
SELECT * FROM aurora_stat_reset_wal_cache(NULL)
```
## Argumen
`NULL` atau `slot_name`
## Jenis pengembalian
Pesan status, string teks
+ Atur ulang penghitung cache wal logis - Pesan sukses. Teks ini dikembalikan ketika fungsi berhasil.
+ Slot replikasi tidak ditemukan. Coba lagi. – Pesan kegagalan. Teks ini dikembalikan ketika fungsi tidak berhasil.
## Catatan penggunaan
Fungsi ini tersedia untuk versi berikut.
+ Aurora PostgreSQL versi 14.5 dan lebih tinggi
+ Aurora PostgreSQL versi 13.8 dan lebih tinggi
+ Aurora PostgreSQL versi 12.12 dan lebih tinggi
+ Aurora SQLversion Postgre 11.17 dan lebih tinggi
## Contoh
Contoh berikut menggunakan fungsi `aurora_stat_reset_wal_cache` untuk mengatur ulang slot bernama `test_results`, dan kemudian mencoba untuk mengatur ulang slot yang tidak ada.
```
=> 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
Melaporkan pemanfaatan sumber daya real-time yang terdiri dari metrik sumber daya backend dan penggunaan cpu untuk semua proses backend Aurora PostgreSQL.
## Sintaksis
```
aurora_stat_resource_usage()
```
## Argumen
Tidak ada
## Jenis pengembalian
Rekam SETOF dengan kolom:
+ pid - Pengidentifikasi proses
+ allocated\$1memory - Total memori yang dialokasikan oleh proses dalam byte
+ used\$1memory - Sebenarnya menggunakan memori dengan proses dalam byte
+ cpu\$1usage\$1percent - Persentase penggunaan CPU dari proses
## Catatan penggunaan
Fungsi ini menampilkan penggunaan sumber daya backend untuk setiap proses backend Aurora PostgreSQL.
Fungsi ini tersedia mulai dengan versi Aurora PostgreSQL berikut:
+ Aurora PostgreSQL 17.5 dan versi 17 yang lebih tinggi
+ Aurora PostgreSQL 16.9 dan versi 16 yang lebih tinggi
+ Aurora PostgreSQL 15.13 dan versi 15 yang lebih tinggi
+ Aurora PostgreSQL 14.18 dan versi 14 yang lebih tinggi
+ Aurora PostgreSQL 13.21 dan versi 13 yang lebih tinggi
## Contoh
Contoh berikut menunjukkan output dari `aurora_stat_resource_usage` fungsi.
```
=> 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
Menampilkan semua kolom `pg_stat_statements` dan menambahkan lebih banyak kolom pada akhirnya.
## Sintaksis
```
aurora_stat_statements(showtext boolean)
```
## Argumen
*showtext boolean*
## Jenis pengembalian
Catatan SETOF dengan semua kolom `pg_stat_statements` dan kolom tambahan berikut. Untuk informasi selengkapnya tentang kolom `pg_stat_statements`, lihat [https://www.postgresql.org/docs/current/pgstatstatements.html](https://www.postgresql.org/docs/current/pgstatstatements.html).
Anda dapat mengatur ulang statistik untuk fungsi ini menggunakan `pg_stat_statements_reset()`.
+ `storage_blks_read` – Jumlah total blok bersama yang dibaca dari penyimpanan aurora oleh pernyataan ini.
+ `orcache_blks_hit` – Jumlah total hit cache pembacaan yang dioptimalkan oleh pernyataan ini.
+ `storage_blk_read_time`— Jika `track_io_timing` diaktifkan, ia melacak total waktu pernyataan yang dihabiskan untuk membaca blok bersama dari penyimpanan aurora, dalam milidetik, jika tidak nilainya nol. Untuk informasi selengkapnya, lihat [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
+ `local_blk_read_time`— Jika `track_io_timing` diaktifkan, ia melacak total waktu pernyataan yang dihabiskan untuk membaca blok lokal, dalam milidetik, jika tidak nilainya nol. Untuk informasi selengkapnya, lihat [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
+ `orcache_blk_read_time`— Jika `track_io_timing` diaktifkan, ia melacak total waktu pernyataan yang dihabiskan untuk membaca blok bersama dari cache pembacaan yang dioptimalkan, dalam milidetik, jika tidak nilainya nol. Untuk informasi selengkapnya, lihat [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
+ `total_plan_peakmem`— Jumlah total nilai memori puncak selama fase perencanaan untuk semua panggilan ke pernyataan ini. Untuk melihat memori puncak rata-rata selama perencanaan pernyataan, bagi nilai ini dengan jumlah panggilan.
+ `min_plan_peakmem`— Nilai memori puncak terkecil yang terlihat selama perencanaan di semua panggilan ke pernyataan ini.
+ `max_plan_peakmem`— Nilai memori puncak terbesar selama perencanaan terlihat di semua panggilan ke pernyataan ini.
+ `total_exec_peakmem`— Jumlah total nilai memori puncak selama fase eksekusi untuk semua panggilan ke pernyataan ini. Untuk melihat memori puncak rata-rata selama eksekusi untuk pernyataan, bagi nilai ini dengan jumlah panggilan.
+ `min_exec_peakmem`—Nilai memori puncak terkecil, dalam byte, terlihat selama eksekusi di semua panggilan ke pernyataan ini.
+ `max_exec_peakmem`— Nilai memori puncak terbesar, dalam byte, terlihat selama eksekusi di semua panggilan ke pernyataan ini.
**catatan**
`total_plan_peakmen`,`min_plan_peakmem`, dan hanya `max_plan_peakmem` dipantau saat pengaturan `pg_stat_statements.track_planning` dihidupkan.
## Catatan penggunaan
Untuk menggunakan fungsi aurora\$1stat\$1statements (), Anda harus menyertakan ekstensi dalam parameter. `pg_stat_statements` `shared_preload_libraries`
Fungsi ini tersedia di versi Aurora PostgreSQL berikut:
+ Versi 15.4 dan versi 15 yang lebih tinggi
+ Versi 14.9 dan versi 14 yang lebih tinggi
Kolom yang menunjukkan memori puncak tersedia dari versi berikut:
+ 16.3 dan versi yang lebih tinggi
+ 15.7 dan versi yang lebih tinggi
+ 14.12 dan versi yang lebih tinggi
## Contoh
Contoh berikut menunjukkan bagaimana ia membawa semua kolom pg\$1stat\$1statement dan menambahkan 11 kolom baru pada akhirnya:
```
=> 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
Melaporkan informasi peristiwa tunggu untuk instans DB Aurora PostgreSQL.
## Sintaksis
```
aurora_stat_system_waits()
```
## Argumen
Tidak ada
## Jenis pengembalian
Catatan SETOF
## Catatan penggunaan
Fungsi ini mengembalikan jumlah tunggu kumulatif dan waktu tunggu kumulatif untuk setiap peristiwa tunggu yang dihasilkan oleh instans DB yang saat ini terhubung.
Recordset yang dikembalikan mencakup kolom-kolom berikut:
+ `type_id` – ID dari jenis peristiwa tunggu.
+ `event_id` – ID dari peristiwa tunggu.
+ `waits` – Jumlah peristiwa menunggu terjadi.
+ `wait_time` – Jumlah total waktu dalam mikrodetik yang dihabiskan menunggu peristiwa ini.
Statistik yang dikembalikan oleh fungsi ini diatur ulang ketika instans DB dimulai ulang.
## Contoh
Contoh berikut menampilkan hasil dari pemanggilan fungsi `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
```
Contoh berikut menampilkan cara menggunakan fungsi ini bersama-sama dengan `aurora_stat_wait_event` dan `aurora_stat_wait_type` untuk menghasilkan hasil yang lebih mudah dibaca.
```
=> 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
Daftar semua peristiwa tunggu yang didukung untuk Aurora PostgreSQL. Untuk informasi tentang peristiwa tunggu Aurora PostgreSQL, lihat [Peristiwa tunggu Amazon Aurora PostgreSQL](AuroraPostgreSQL.Reference.Waitevents.md).
## Sintaksis
```
aurora_stat_wait_event()
```
## Argumen
Tidak ada
## Jenis pengembalian
Catatan SETOF dengan kolom berikut:
+ type\$1id – ID dari jenis peristiwa tunggu.
+ event\$1id – ID dari peristiwa tunggu.
+ type\$1name – Nama jenis tunggu
+ event\$1name – Nama peristiwa tunggu
## Catatan penggunaan
Untuk melihat nama acara dengan tipe acara, bukan IDs, gunakan fungsi ini bersama dengan fungsi lain seperti `aurora_stat_wait_type` dan`aurora_stat_system_waits`. Nama peristiwa tunggu yang dikembalikan oleh fungsi ini sama dengan yang dikembalikan oleh fungsi `aurora_wait_report`.
## Contoh
Contoh berikut menampilkan hasil dari pemanggilan fungsi `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
```
Contoh berikut menggabungkan `aurora_stat_wait_type` dan `aurora_stat_wait_event` untuk mengembalikan nama jenis dan nama peristiwa untuk meningkatkan keterbacaan.
```
=> 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
Daftar semua jenis tunggu yang didukung untuk Aurora PostgreSQL.
## Sintaksis
```
aurora_stat_wait_type()
```
## Argumen
Tidak ada
## Jenis pengembalian
Catatan SETOF dengan kolom berikut:
+ type\$1id – ID dari jenis peristiwa tunggu.
+ type\$1name – Nama jenis tunggu.
## Catatan penggunaan
Untuk melihat nama acara tunggu dengan tipe acara tunggu alih-alih IDs, gunakan fungsi ini bersama dengan fungsi lain seperti `aurora_stat_wait_event` dan`aurora_stat_system_waits`. Nama peristiwa tunggu yang dikembalikan oleh fungsi ini sama dengan yang dikembalikan oleh fungsi `aurora_wait_report`.
## Contoh
Contoh berikut menampilkan hasil dari pemanggilan fungsi `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
Mengembalikan nilai string nomor versi Amazon Aurora Edisi Kompatibel PostgreSQL.
## Sintaksis
```
aurora_version()
```
## Argumen
Tidak ada
## Jenis pengembalian
String CHAR atau VARCHAR
## Catatan penggunaan
Fungsi ini menampilkan versi mesin basis data Amazon Aurora Edisi Kompatibel PostgreSQL. Nomor versi dikembalikan sebagai string yang diformat sebagai*major*. *minor*. *patch*. Untuk informasi selengkapnya tentang nomor versi Aurora PostgreSQL, lihat [Nomor versi Aurora](AuroraPostgreSQL.Updates.md#AuroraPostgreSQL.Updates.Versions.AuroraNumber).
Anda dapat memilih kapan harus menerapkan peningkatan versi minor dengan mengatur jendela pemeliharaan untuk klaster DB Aurora PostgreSQL. Untuk mempelajari caranya, lihat [Memelihara klaster DB Amazon Aurora](USER_UpgradeDBInstance.Maintenance.md).
Mulai dengan rilis Aurora PostgreSQL versi 13.3, 12.8, 11.13, 10.18, dan untuk semua versi lain yang lebih baru, nomor versi Aurora mengikuti nomor versi PostgreSQL. Untuk informasi selengkapnya tentang semua rilis Aurora PostgreSQL, lihat [Pembaruan Amazon Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Updates.html) di *Catatan Rilis untuk Aurora PostgreSQL*.
## Contoh
Contoh berikut menunjukkan hasil pemanggilan fungsi `aurora_version` pada klaster DB Aurora PostgreSQL yang menjalankan [PostgreSQL 12.7, Aurora PostgreSQL rilis 4.2](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Updates.html#AuroraPostgreSQL.Updates.20180305.42) dan kemudian menjalankan fungsi yang sama pada klaster yang menjalankan [Aurora PostgreSQL versi 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
```
Contoh ini menunjukkan cara menggunakan fungsi dengan berbagai opsi untuk mendapatkan detail selengkapnya tentang versi Aurora PostgreSQL. Contoh ini memiliki nomor versi Aurora yang berbeda dari nomor versi 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)
```
Contoh berikutnya ini menggunakan fungsi dengan opsi yang sama pada contoh sebelumnya. Contoh ini memiliki nomor versi Aurora yang berbeda dari nomor versi 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
Mengembalikan nomor urutan log (LSN) yang digunakan untuk mengidentifikasi awal catatan dalam aliran log write-ahead (WAL) logis dari volume klaster Aurora.
## Sintaksis
```
aurora_volume_logical_start_lsn()
```
## Argumen
Tidak ada
## Jenis pengembalian
`pg_lsn`
## Catatan penggunaan
Fungsi ini mengidentifikasi awal catatan dalam aliran WAL logis untuk volume klaster Aurora tertentu. Anda dapat menggunakan fungsi ini saat melakukan peningkatan versi mayor menggunakan replikasi logis dan kloning cepat Aurora untuk menentukan LSN tempat snapshot atau klona basis data diambil. Setelah itu, Anda dapat menggunakan replikasi logis untuk terus mengalirkan data baru yang dicatat setelah LSN dan menyinkronkan perubahan dari penerbit ke pelanggan.
Untuk informasi selengkapnya tentang penggunaan replikasi logis untuk meningkatkan versi mayor, lihat [Menggunakan replikasi logis untuk melakukan peningkatan versi mayor untuk Aurora PostgreSQL](AuroraPostgreSQL.MajorVersionUpgrade.md).
Fungsi ini tersedia di versi Aurora PostgreSQL berikut:
+ Versi 15.2 dan versi 15 yang lebih tinggi
+ 14.3 dan versi 14 yang lebih tinggi
+ 13.6 dan versi 13 yang lebih tinggi
+ 12.10 dan versi 12 yang lebih tinggi
+ 11.15 dan versi 11 yang lebih tinggi
+ Versi 10.20 dan versi 10 yang lebih tinggi
## Contoh
Anda dapat memperoleh nomor urutan log (LSN) menggunakan kueri berikut:
```
postgres=> SELECT aurora_volume_logical_start_lsn();
aurora_volume_logical_start_lsn
---------------
0/402E2F0
(1 row)
```
# aurora\$1wait\$1report
Fungsi ini menunjukkan aktivitas peristiwa tunggu selama periode waktu tertentu.
## Sintaksis
```
aurora_wait_report([time])
```
## Argumen
*waktu (opsional)*
Waktu dalam hitungan detik. Default-nya 10 detik.
## Jenis pengembalian
Catatan SETOF dengan kolom berikut:
+ type\$1name – Nama jenis tunggu
+ event\$1name – Nama peristiwa tunggu
+ wait – Jumlah tunggu
+ wait\$1time - Waktu tunggu dalam milidetik
+ ms\$1per\$1wait - Rata-rata milidetik berdasarkan jumlah sekali tunggu
+ waits\$1per\$1xact – Rata-rata tunggu berdasarkan jumlah satu transaksi
+ ms\$1per\$1xact - Rata-rata milidetik berdasarkan jumlah transaksi
## Catatan penggunaan
Fungsi ini tersedia pada rilis Aurora PostgreSQL 1.1 kompatibel dengan PostgreSQL 9.6.6 dan versi yang lebih tinggi.
Untuk menggunakan fungsi ini, Anda harus terlebih dahulu membuat ekstensi `aurora_stat_utils` Aurora PostgreSQL, sebagai berikut:
```
=> CREATE extension aurora_stat_utils;
CREATE EXTENSION
```
Untuk informasi selengkapnya tentang versi ekstensi Aurora PostgreSQL, lihat [Versi ekstensi untuk Amazon Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Extensions.html) di *Catatan Rilis untuk Aurora PostgreSQL*.
Fungsi ini menghitung peristiwa tunggu level instans dengan membandingkan dua snapshot data statistik dari fungsi aurora\$1stat\$1system\$1waits() dan PostgreSQL Statistics Views pg\$1stat\$1database.
Untuk informasi selengkapnya tentang `aurora_stat_system_waits()` dan `pg_stat_database`, lihat [The Statistics Collector](https://www.postgresql.org/docs/current/monitoring-stats.html#PG-STAT-DATABASE-VIEW) di *dokumentasi PostgreSQL*.
Saat dijalankan, fungsi ini mengambil snapshot awal, menunggu jumlah detik yang ditentukan, dan kemudian mengambil snapshot kedua. Fungsi tersebut membandingkan dua snapshot dan mengembalikan perbedaannya. Perbedaan ini mewakili aktivitas instans untuk interval waktu tersebut.
Pada instans penulis, fungsi ini juga menampilkan jumlah transaksi yang dilakukan dan TPS (transaksi per detik). Fungsi ini mengembalikan informasi pada tingkat instans dan mencakup semua basis data pada instans.
## Contoh
Contoh ini menunjukkan cara membuat ekstensi aurora\$1stat\$1utils agar dapat menggunakan fungsi aurora\$1wait\$1report.
```
=> CREATE extension aurora_stat_utils;
CREATE EXTENSION
```
Contoh ini menunjukkan cara memeriksa laporan tunggu selama 10 detik.
```
=> 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
```
Contoh ini menunjukkan cara memeriksa laporan tunggu selama 60 detik.
```
=> 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
```