Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Riferimento Amazon Aurora PostgreSQL
Nei seguenti argomenti sono disponibili informazioni su regole di confronto, funzioni, parametri ed eventi di attesa in Amazon Aurora PostgreSQL.
**Topics**
+ [Fascicolazioni Aurora PostgreSQL per EBCDIC e altre migrazioni del mainframe](#AuroraPostgreSQL.Reference.Collations.mainframe.migration)
+ [Collation supportate in Aurora PostgreSQL RDS per](PostgreSQL-Collations.md)
+ [Riferimenti relativi alle funzioni Aurora PostgreSQL](Appendix.AuroraPostgreSQL.Functions.md)
+ [Amazon Aurora PostgreSQL parametri](AuroraPostgreSQL.Reference.ParameterGroups.md)
+ [Eventi di attesa Amazon Aurora PostgreSQL](AuroraPostgreSQL.Reference.Waitevents.md)
## Fascicolazioni Aurora PostgreSQL per EBCDIC e altre migrazioni del mainframe
La migrazione delle applicazioni mainframe a nuove piattaforme quali AWS preserva idealmente il comportamento dell'applicazione. Per mantenere il comportamento dell’applicazione su una nuova piattaforma esattamente come era sul mainframe, è necessario che i dati migrati vengano fascicolati utilizzando le stesse regole di fascicolazione e ordinamento. Ad esempio, molte soluzioni di migrazione Db2 spostano valori nulli in u0180 (posizione Unicode 0180), pertanto queste fascicolazioni ordinano prima u0180. Questo è un esempio di come le fascicolazioni possono variare rispetto all'origine del mainframe e perché è necessario scegliere una fascicolazione che si meglio mappata alla fascicolazione EBCDIC originale.
Aurora PostgreSQL 14.3 e versioni successive forniscono molte fascicolazioni ICU ed EBCDIC per supportare tale migrazione verso AWS utilizzando il servizio Modernizzazione del mainframe AWS. Per ulteriori informazioni su questo servizio, consulta [Cos'è Modernizzazione del mainframe AWS?](https://docs.aws.amazon.com/m2/latest/userguide/what-is-m2.html)
Nella tabella seguente, sono disponibili le fascicolazioni fornite da Aurora PostgreSQL. Queste fascicolazioni seguono le regole EBCDIC e garantiscono che le applicazioni mainframe funzionino allo stesso modo su AWS come nell'ambiente mainframe. Il nome della fascicolazione include la pagina di codice pertinente, (cp*nnnn*), per poter scegliere la fascicolazione appropriata per l’origine del mainframe. Ad esempio, utilizza `en-US-cp037-x-icu` per ottenere il comportamento di fascicolazione per i dati EBCDIC provenienti da un'applicazione mainframe che utilizza la pagina codice 037.
| Fascicolazioni EBCDIC | Fascicolazioni AWS Blu Age | Fascicolazioni AWS Micro Focus |
| --- | --- | --- |
| da-DK-cp1142-x-icu | da-DK-cp1142-x-icu | da-DK-cp1142m-x-icu |
| da-DK-cp277-x-icu | da-DK-cp277b-x-icu | – |
| de-DE-cp1141-x-icu | de-DE-cp1141b-x-icu | de-DE-cp1141m-x-icu |
| de-DE-cp273-x-icu | de-DE-cp273b-x-icu | – |
| en-GB-cp1146-x-icu | en-GB-cp1146b-x-icu | en-GB-cp1146m-x-icu |
| en-GB-cp285-x-icu | en-GB-cp285b-x-icu | – |
| en-US-cp037-x-icu | en-US-cp037b-x-icu | – |
| en-US-cp1140-x-icu | en-US-cp1140b-x-icu | en-US-cp1140m-x-icu |
| es-ES-cp1145-x-icu | es-ES-cp1145b-x-icu | es-ES-cp1145b-x-icu |
| es-ES-cp284-x-icu | es-ES-cp284b-x-icu | – |
| fi-FI-cp1143-x-icu | fi-FI-cp1143b-x-icu | fi-FI-cp1143m-x-icu |
| fi-FI-cp278-x-icu | fi-FI-cp278b-x-icu | – |
| FR-FR-CP1147-x-ICU | fr-FR-cp1147b-x-icu | fr-FR-cp1147m-x-icu |
| fr-FR-cp297-x-icu | fr-FR-cp297b-x-icu | – |
| it-IT-cp1144-x-icu | it-IT-cp1144b-x-icu | it-IT-cp1144b-x-icu |
| it-IT-cp280-x-icu | it-IT-cp280b-x-icu | – |
| nl-BE-cp1148-x-icu | nl-BE-cp1148b-x-icu | nl-BE-cp1148m-x-icu |
| nl-BE-cp500-x-icu | nl-BE-cp500b-x-icu | – |
Per ulteriori informazioni su AWS Blu Age, consulta [Tutorial: Runtime gestito per AWS Blu Age](https://docs.aws.amazon.com/m2/latest/userguide/tutorial-runtime-ba.html) nella *Guida per l'utente di Modernizzazione mainframe AWS*.
Per ulteriori informazioni sull'utilizzo di AWS Micro Focus, consulta [Tutorial: Managed Runtime for Micro Focus](https://docs.aws.amazon.com/m2/latest/userguide/tutorial-runtime.html) nella *Guida per l’utente di Modernizzazione mainframe AWS*.
Per ulteriori informazioni sulla gestione di fascicolazioni in PostgreSQL, consulta [Collation Support](https://www.postgresql.org/docs/current/collation.html) nella documentazione di PostgreSQL.
# Collation supportate in Aurora PostgreSQL RDS per
Le regole di confronto sono un insieme di regole che determinano il modo in cui le stringhe di caratteri archiviate nel database vengono ordinate e confrontate. Le regole di confronto svolgono un ruolo fondamentale nel sistema del computer e sono incluse come parte del sistema operativo. Le regole di confronto cambiano nel tempo quando vengono aggiunti nuovi caratteri alle lingue o quando vengono modificate le regole di ordinamento.
Le librerie di regole di confronto definiscono regole e algoritmi specifici per una regola di confronto. Le librerie di regole di confronto più popolari utilizzate in PostgreSQL sono GNU C (glibc) e Internationalization components for Unicode (ICU). Per impostazione predefinita, Aurora PostgreSQL utilizza la regola di confronto glibc che include le sequenze di ordinamento dei caratteri unicode per sequenze di caratteri multibyte.
Quando si crea un nuovo cluster database Aurora PostgreSQL, viene cercata la regola di confronto disponibile nel sistema operativo. I parametri PostgreSQL `LC_COLLATE` e `LC_CTYPE` del comando `CREATE DATABASE` vengono utilizzati per specificare una regola di confronto, che rappresenta la regola di confronto predefinita nel database. In alternativa, puoi anche usare il parametro `LOCALE` in `CREATE DATABASE` per impostare questi parametri e determinare la regole di confronto predefinita per le stringhe di caratteri nel database e le regole per classificare i caratteri come lettere, numeri o simboli. Puoi anche scegliere una regola di confronto da utilizzare per una colonna, un indice o una query.
Aurora PostgreSQL dipende dalla libreria glibc del sistema operativo per il supporto della regola di confronto. L'istanza Aurora PostgreSQL viene aggiornata periodicamente con le versioni più recenti del sistema operativo. Questi aggiornamenti a volte includono una nuova versione della libreria glibc. Raramente, le versioni più recenti della libreria glibc modificano l'ordinamento o la regola di confronto di alcuni caratteri e pertanto i dati possono essere ordinati in modo diverso o produrre voci di indice non valide. Se si riscontrano problemi di ordinamento per la regola di confronto durante un aggiornamento, potrebbe essere necessario ricostruire gli indici.
Per ridurre il possibile impatto degli aggiornamenti della libreria glibc, Aurora PostgreSQL ora include una libreria di regole di confronto predefinita indipendente. Questa libreria di regole confronto è disponibile in Aurora PostgreSQL 14.6, 13.9, 12.13, 11.18 e versioni secondarie successive. È compatibile con glibc 2.26-59.amzn2 e fornisce stabilità dell'ordinamento per evitare risultati errati delle query.
# Riferimenti relativi alle funzioni Aurora PostgreSQL
Di seguito, è possibile trovare un elenco delle funzioni Aurora PostgreSQL disponibili per i cluster Aurora DB che eseguono il motore di database dell’edizione compatibile con Aurora PostgreSQL. Queste funzioni Aurora PostgreSQL sono in aggiunta alle funzioni standard PostgreSQL. Per ulteriori informazioni sulle funzioni PostgreSQL standard, consulta [PostgreSQL: funzioni e operatori](https://www.postgresql.org/docs/current/functions.html).
## Panoramica di
È possibile utilizzare le seguenti funzioni per le istanze database Amazon RDS che eseguono 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
Comunica il nome dell'istanza database cui si è connessi.
## Sintassi
```
aurora_db_instance_identifier()
```
## Argomenti
Nessuno
## Tipo restituito
Stringa VARCHA
## Note per l'utilizzo
Questa funzione visualizza il nome dell'istanza database del cluster Aurora edizione compatibile con PostgreSQL per la connessione al client di database o all'applicazione.
Questa funzione è disponibile a partire dal rilascio di PostgreSQL versioni 13.7, 12.11, 11.16, 10.21 e per tutte le altre versioni successive.
## Esempi
Nell'esempio seguente vengono mostrati i risultati della chiamata della funzione `aurora_db_instance_identifier`.
```
=> SELECT aurora_db_instance_identifier();
aurora_db_instance_identifier
-------------------------------
test-my-instance-name
```
È possibile unire i risultati di questa funzione con la funzione `aurora_replica_status` per ottenere i dettagli relativi all'istanza database per la connessione. Il parametro [aurora\$1replica\$1status](aurora_replica_status.md) da solo non mostra l’istanza database in uso. Nell'esempio seguente viene illustrato come fare.
```
=> 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
Visualizza lo stato del gestore della cache del cluster.
## Sintassi
```
aurora_ccm_status()
```
## Argomenti
Nessuna.
## Tipo restituito
Record SETOF avente le seguenti colonne:
+ `buffers_sent_last_minute`: il numero di buffer inviati all'istanza database di lettura designata nell'ultimo minuto.
+ `buffers_found_last_minute`: il numero di buffer con accesso frequente identificati durante l'ultimo minuto.
+ `buffers_sent_last_scan`: il numero di buffer inviati all'istanza di lettura designata durante l'ultima scansione completa della cache.
+ `buffers_found_last_scan`: il numero di buffer ad accesso frequente inviati durante l'ultima scansione completa della cache. I buffer già memorizzati sull'istanza database di lettura designata non vengono inviati.
+ `buffers_sent_current_scan`: il numero di buffer inviati durante la scansione corrente.
+ `buffers_found_current_scan`: il numero di buffer ad accesso frequente identificati nella scansione corrente.
+ `current_scan_progress`: il numero di buffer analizzati finora durante la scansione corrente.
## Note per l'utilizzo
È possibile utilizzare questa funzione per controllare e monitorare la funzionalità di gestione della cache del cluster (CCM). Ciò può avvenire solo se la funzionalità di gestione della cache del cluster è attiva sul cluster di database Aurora PostgreSQL. Per utilizzare questa funzione, connettersi all'istanza DB di scrittura sul cluster di database Aurora PostgreSQL.
Per attivare la funzionalità di gestione della cache del cluster per un cluster di database Aurora PostgreSQL, impostare `apg_ccm_enabled` su 1 nel gruppo di parametri del cluster di database personalizzato. Per scoprire come, consulta [Configurazione della gestione della cache del cluster](AuroraPostgreSQL.cluster-cache-mgmt.md#AuroraPostgreSQL.cluster-cache-mgmt.Configure).
La gestione della cache del cluster è attiva su un cluster di database Aurora PostgreSQL quando il cluster dispone di un'istanza di lettura Aurora configurata come segue:
+ L'istanza di lettura Aurora utilizza lo stesso tipo di classe di istanza database e la stessa dimensione dell'istanza di scrittura del cluster.
+ L'istanza di lettura Aurora è configurata come Tier-0 per il cluster. Se il cluster include più di un'istanza di lettura, questa istanza sarà l'unica istanza di lettura di tipo Tier-0.
L'impostazione di più di un'istanza di lettura su Tier-0 disabilita la funzionalità di gestione della cache del cluster. Quando la funzionalità di gestione della cache del cluster è disabilitata, una chiamata a questa funzione restituirà il seguente messaggio di errore:
```
ERROR: Cluster Cache Manager is disabled
```
È inoltre possibile impostare l'estensione PostgreSQL pg\$1buffercache affinché analizzi la cache del buffer. Per ulteriori informazioni, consulta [pg\$1buffercache](https://www.postgresql.org/docs/current/pgbuffercache.html) nella documentazione di PostgreSQL.
Per ulteriori informazioni, consulta [Introduzione alla gestione della cache del cluster Aurora PostgreSQL](https://aws.amazon.com/blogs/database/introduction-to-aurora-postgresql-cluster-cache-management/).
## Esempi
Nell'esempio seguente vengono mostrati i risultati della chiamata della funzione `aurora_ccm_status`. Questo primo esempio mostra le statistiche restituite dalla funzionalità di gestione della cache del cluster.
```
=> 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
```
Per dettagli più completi, è possibile utilizzare la visualizzazione espansa, come illustrato di seguito:
```
\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
```
Questo esempio mostra come controllare la frequenza e la percentuale degli avvii a caldo.
```
=> 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
Visualizza lo stato di tutte le istanze Aurora, incluse le repliche in un cluster di database globale Aurora.
## Sintassi
```
aurora_global_db_instance_status()
```
## Argomenti
Nessuno
## Tipo restituito
Record SETOF avente le seguenti colonne:
+ `server_id`: l'identificatore dell'istanza database.
+ `session_id`: un identificatore univoco per la sessione. Il valore di `MASTER_SESSION_ID` identifica l'istanza database di lettura (primaria).
+ `aws_region`: l'Regione AWS in cui viene eseguita l'istanza database globale corrente. Per l'elenco delle regioni , consulta [Disponibilità nelle regioni](Concepts.RegionsAndAvailabilityZones.md#Aurora.Overview.Availability).
+ `durable_lsn`: il numero di sequenza di log (LSN) reso durevole nell'archiviazione. Numero di sequenza di log (LSN) è un numero sequenziale univoco che identifica un record nel log delle transazioni del database. Gli LSN sono ordinati in modo tale che un LSN più grande rappresenti una transazione successiva.
+ `highest_lsn_rcvd`: l'LSN più alto che l'istanza database ha ricevuto dall'istanza database di scrittura.
+ `feedback_epoch`: l'epoca utilizzata dall'istanza database quando genera informazioni standby a caldo. Uno *standby a caldo* è un'istanza database che supporta connessioni e query mentre il database primario è in modalità di ripristino o standby. Le informazioni relative allo standby a caldo includono l'epoca (point-in-time) e altri dettagli sull'istanza database utilizzata come standby a caldo. Per ulteriori informazioni, consulta [Hot Standby](https://www.postgresql.org/docs/current/hot-standby.html) nella documentazione di PostgreSQL.
+ `feedback_xmin`: l'ID della transazione attiva più basso utilizzato dall'istanza database.
+ `oldest_read_view_lsn`: l'LSN più vecchio utilizzato dall'istanza database per le operazioni di lettura dallo storage.
+ `visibility_lag_in_msec`: il ritardo dell'istanza database corrente rispetto all'istanza database di scrittura in millisecondi.
## Note per l'utilizzo
Questa funzione mostra le statistiche di replica per un cluster di database Aurora. Per ogni istanza database Aurora PostgreSQL nel cluster, la funzione mostra una riga di dati che include eventuali repliche tra regioni in una configurazione di database globale.
È possibile eseguire questa funzione da qualsiasi istanza in un cluster di database Aurora PostgreSQL o Aurora PostgreSQL. La funzione restituisce dettagli sul ritardo per tutte le istanze di replica.
Per ulteriori informazioni sul monitoraggio del ritardo utilizzando questa funzione (`aurora_global_db_instance_status`) o `aurora_global_db_status`, consulta [Monitoraggio dei database globali Aurora basati su PostgreSQL](aurora-global-database-monitoring.md#aurora-global-database-monitoring.postgres).
Per informazioni sui database globali Aurora, consulta [Panoramica di Database globale Amazon Aurora](aurora-global-database.md#aurora-global-database-overview).
Per iniziare a utilizzare i database globali Aurora, consulta [Nozioni di base sul Database globale Amazon Aurora](aurora-global-database-getting-started.md) o [Domande frequenti su Amazon Aurora](https://aws.amazon.com/rds/aurora/faqs/).
## Esempi
Questo esempio mostra le statistiche delle istanze tra regioni.
```
=> 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
```
Questo esempio mostra come controllare il ritardo delle repliche globali in millisecondi.
```
=> 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
```
Questo esempio mostra come controllare il ritardo minimo, massimo e medio per Regione AWS rispetto alla configurazione del database globale.
```
=> SELECT 'Secondary' global_role,
aws_region,
min(visibility_lag_in_msec) min_lag_in_msec,
max(visibility_lag_in_msec) max_lag_in_msec,
round(avg(visibility_lag_in_msec),0) avg_lag_in_msec
FROM aurora_global_db_instance_status()
WHERE aws_region NOT IN (SELECT aws_region
FROM aurora_global_db_instance_status()
WHERE session_id='MASTER_SESSION_ID')
GROUP BY aws_region
UNION ALL
SELECT 'Primary' global_role,
aws_region,
NULL,
NULL,
NULL
FROM aurora_global_db_instance_status()
WHERE session_id='MASTER_SESSION_ID'
ORDER BY 1, 5;
global_role | aws_region | min_lag_in_msec | max_lag_in_msec | avg_lag_in_msec
------------+--------------+-----------------+-----------------+-----------------
Primary | eu-west-1 | [NULL] | [NULL] | [NULL]
Secondary | eu-central-1 | 133 | 133 | 133
Secondary | eu-west-2 | 0 | 495 | 248
```
# aurora\$1global\$1db\$1status
Visualizza informazioni su vari aspetti del ritardo del database globale Aurora, in particolare il ritardo dell'archiviazione Aurora sottostante (il cosiddetto ritardo di durabilità) e il ritardo rispetto all'obiettivo del punto di ripristino (RPO).
## Sintassi
```
aurora_global_db_status()
```
## Argomenti
Nessuna.
## Tipo restituito
Record SETOF avente le seguenti colonne:
+ `aws_region`: la Regione AWS in cui si trova il cluster di database corrente. Per un elenco completo di Regioni AWS per motore, consulta [ Regioni e zone di disponibilità](Concepts.RegionsAndAvailabilityZones.md).
+ `highest_lsn_written`: il numero di sequenza di log (LSN) più alto attualmente esistente in questo cluster di database. Numero di sequenza di log (LSN) è un numero sequenziale univoco che identifica un record nel log delle transazioni del database. Gli LSN sono ordinati in modo tale che un LSN più grande rappresenti una transazione successiva.
+ `durability_lag_in_msec`: la differenza tra i valori di timestamp tra `highest_lsn_written` su un cluster di database secondario e `highest_lsn_written` sul cluster di database primario. Un valore -1 identifica il cluster di database globale principale di un database globale Aurora.
+ `rpo_lag_in_msec`: il ritardo dell'obiettivo del punto di ripristino (RPO). Il ritardo dell'obiettivo del punto di ripristino (RPO) è il tempo necessario per memorizzare il COMMIT delle transazioni utente più recenti dopo la sua memorizzazione nel cluster di database primario del database globale Aurora. Un valore -1 indica il cluster di database primario e quindi il ritardo non è rilevante.
In sintesi, questo parametro calcola l'obiettivo del punto di ripristino per ciascun cluster di database Aurora PostgreSQL nel database globale Aurora, ovvero quanti dati potrebbero andare perduti in caso di interruzione. Come per il ritardo, l'obiettivo del punto di ripristino (RPO) viene misurato nel tempo.
+ `last_lag_calculation_time`: il timestamp che specifica quando sono stati calcolati i valori per `durability_lag_in_msec` e `rpo_lag_in_msec`. Il valore temporale `1970-01-01 00:00:00+00` indica che questo è il cluster di database primario.
+ `feedback_epoch`: l'epoca utilizzata dal cluster di database secondario quando genera informazioni sullo standby a caldo. Uno *standby a caldo* è un'istanza database che supporta connessioni e query mentre il database primario è in modalità di ripristino o standby. Le informazioni relative allo standby a caldo includono l'epoca (point-in-time) e altri dettagli sull'istanza database utilizzata come standby a caldo. Per ulteriori informazioni, consulta [Hot Standby](https://www.postgresql.org/docs/current/hot-standby.html) nella documentazione di PostgreSQL.
+ `feedback_xmin`: l'ID minimo della transazione attiva (meno recente) utilizzato da un cluster di database secondario.
## Note per l’utilizzo
Tutte le versioni di Aurora PostgreSQL attualmente disponibili supportano questa funzione. Questa funzione mostra le statistiche di replica per un database globale Aurora. Mostra una riga per ciascun cluster di database in un database globale Aurora PostgreSQL. È possibile eseguire questa funzione da qualsiasi istanza del database globale Aurora PostgreSQL.
Per valutare il ritardo di replica del database globale Aurora, ovvero il ritardo visibile dei dati, consulta [aurora\$1global\$1db\$1instance\$1status](aurora_global_db_instance_status.md).
Per ulteriori informazioni sull'uso di `aurora_global_db_status` e `aurora_global_db_instance_status` per monitorare il ritardo del database globale Aurora, consulta [Monitoraggio dei database globali Aurora basati su PostgreSQL](aurora-global-database-monitoring.md#aurora-global-database-monitoring.postgres). Per informazioni sui database globali Aurora, consulta [Panoramica di Database globale Amazon Aurora](aurora-global-database.md#aurora-global-database-overview).
## Esempi
Questo esempio mostra come visualizzare le statistiche di archiviazione tra regioni.
```
=> 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
Elenca tutte le funzioni integrate di Aurora PostgreSQL disponibili, insieme a brevi descrizioni e dettagli delle funzioni.
## Sintassi
```
aurora_list_builtins()
```
## Argomenti
Nessuno
## Tipo restituito
Record SETOF
## Esempi
Nell'esempio seguente vengono mostrati i risultati della chiamata alla funzione `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
Visualizza lo stato di tutti i nodi del lettore Aurora PostgreSQL.
## Sintassi
```
aurora_replica_status()
```
## Argomenti
Nessuno
## Tipo restituito
Record SETOF avente le seguenti colonne:
+ `server_id`: ID dell’istanza database (identificatore).
+ `session_id`: un identificatore univoco per la sessione corrente, restituito per l’istanza primaria e le istanze di lettura nel modo seguente:
+ Per l'istanza primaria, il `session_id` è sempre ``MASTER_SESSION_ID’`.
+ Per le istanze di lettura, il `session_id` è sempre l'`UUID` (universally unique identifier, identificatore univoco universale) dell'istanza di lettura.
+ `durable_lsn`: numero di sequenza di log (log sequence number, LSN) archiviato nello storage.
+ Per il volume primario, l'LSN (VDL) durevole del primario attualmente in uso.
+ Per tutti i volumi secondari, il VDL del primario a cui è stato applicato correttamente il secondario.
**Nota**
Numero di sequenza di log (LSN) è un numero sequenziale univoco che identifica un record nel log delle transazioni del database. Gli LSN sono ordinati in modo tale che quelli più grandi rappresentino una transizione successiva.
+ `highest_lsn_rcvd`: l'LSN più alto (più recente) che l'istanza database ha ricevuto dall'istanza database di scrittura.
+ `current_read_lsn`: l'LSN della snapshot più recente applicato a tutte le operazioni di lettura.
+ `cur_replay_latency_in_usec`: tempo previsto in millisecondi per riprodurre il log sul secondario.
+ `active_txns`: numero di transazioni attualmente attive.
+ `is_current`: non utilizzato.
+ `last_transport_error`: codice di errore dell'ultima replica.
+ `last_error_timestamp`: timestamp dell'ultimo errore di replica.
+ `last_update_timestamp`: timestamp dell'ultimo aggiornamento allo stato della replica. Da Aurora PostgreSQL versione 13.9, il valore `last_update_timestamp` per l'istanza database a cui si è connessi è impostato su `NULL`.
+ `feedback_xmin`: feedback\$1xmin della replica in standby a caldo. L'ID della transazione attiva più basso (meno recente) utilizzato dall'istanza database.
+ `feedback_epoch`: l'epoca utilizzata dall'istanza database quando genera informazioni standby a caldo.
+ `replica_lag_in_msec`: ritardo dell’istanza di lettura rispetto a quella di scrittura misurato in millisecondi.
+ `log_stream_speed_in_kib_per_second`: la velocità effettiva del flusso di log in kilobyte al secondo.
+ `log_buffer_sequence_number`: il numero di sequenza del buffer di registro.
+ `oldest_read_view_trx_id`: non utilizzato.
+ `oldest_read_view_lsn`: l'LSN più vecchio utilizzato dall'istanza database per le operazioni di lettura dallo storage.
+ `pending_read_ios`: le letture di pagina in sospeso sulla replica.
+ `read_ios`: il numero totale di letture di pagina sulla replica.
+ `iops`: non utilizzato.
+ `cpu`: utilizzo della CPU di Aurora Storage Daemon per ogni nodo del cluster. Per informazioni sull'utilizzo della CPU da parte dell'istanza, consulta [Parametri a livello di istanza per Amazon Aurora](Aurora.AuroraMonitoring.Metrics.md#Aurora.AuroraMySQL.Monitoring.Metrics.instances).
## Note per l’utilizzo
Tutte le versioni di Aurora PostgreSQL attualmente disponibili supportano questa funzione. La funzione `aurora_replica_status` restituisce i valori del gestore di stato della replica di un cluster database Aurora PostgreSQL. Utilizza questa funzione per ottenere informazioni sullo stato della replica sul cluster database Aurora PostgreSQL, inclusi i parametri per tutte le istanze database nel cluster database Aurora. Ad esempio, puoi eseguire le operazioni seguenti:
+ **Ottenere informazioni sul tipo di istanza (di scrittura, di lettura) nel cluster database Aurora PostgreSQL**. Per ottenere queste informazioni, controlla i valori contenuti nelle colonne seguenti:
+ `server_id`: contiene il nome dell'istanza specificato durante la sua creazione. In alcuni casi, ad esempio per l'istanza primaria (di scrittura), il nome viene generato automaticamente aggiungendo *-instance-1* al nome creato per il cluster database Aurora PostgreSQL.
+ `session_id`: il campo `session_id` indica se l'istanza è di lettura o di scrittura. Per un'istanza di scrittura, `session_id` è sempre impostato su `"MASTER_SESSION_ID"`. Per un'istanza di lettura, `session_id` è impostato sull'`UUID` del lettore specifico.
+ **Diagnostica dei problemi comuni correlati alle repliche, come il ritardo di replica**. Il ritardo di replica indica il ritardo in millisecondi della cache di pagina di un'istanza di lettura rispetto a quella dell'istanza di scrittura. Questo ritardo si verifica perché i cluster Aurora utilizzano la replica asincrona, come descritto in [Replica con Amazon Aurora](Aurora.Replication.md). Nella colonna `replica_lag_in_msec` sono mostrati i risultati restituiti da questa funzione. Il ritardo può verificarsi anche quando una query viene annullata a causa di conflitti con il ripristino su un server in standby. È possibile verificare se il ritardo di replica è causato o meno da questo conflitto controllando `pg_stat_database_conflicts()`. Per ulteriori informazioni, consulta [Raccolta di statistiche](https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-DATABASE-CONFLICTS-VIEW) nella *Documentazione di PostgreSQL*. Per ulteriori informazioni sulla disponibilità elevata e la replica, consulta [Domande frequenti su Amazon Aurora](https://aws.amazon.com/rds/aurora/faqs/#High_Availability_and_Replication).
Amazon CloudWatch archivia i risultati di `replica_lag_in_msec` nel tempo, come parametro `AuroraReplicaLag`. Per ulteriori informazioni sull’utilizzo dei parametri CloudWatch per Aurora, consulta [Monitoraggio dei parametri di Amazon Aurora con Amazon CloudWatch](monitoring-cloudwatch.md)
Per ulteriori informazioni sulla risoluzione dei problemi relativi alla lettura e al riavvio di Aurora, consulta [Perché la mia replica Amazon Aurora è in ritardo e si è riavviata?](https://aws.amazon.com/premiumsupport/knowledge-center/aurora-read-replica-restart/) nel [Centro Supporto AWS](https://console.aws.amazon.com/support/home#/).
## Esempi
L'esempio seguente mostra come ottenere lo stato di replica di tutte le istanze in un cluster database Aurora PostgreSQL:
```
=> SELECT *
FROM aurora_replica_status();
```
L'esempio seguente mostra l'istanza di lettura nel cluster database `docs-lab-apg-main` Aurora PostgreSQL:
```
=> 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
```
Nell'esempio seguente sono elencate tutte le istanze di lettura in un cluster:
```
=> SELECT server_id,
CASE
WHEN 'MASTER_SESSION_ID' = session_id THEN 'writer'
ELSE 'reader'
END AS instance_role
FROM aurora_replica_status()
WHERE session_id <> 'MASTER_SESSION_ID';
server_id | instance_role
------------------------+---------------
db-119-001-instance-02 | reader
db-119-001-instance-03 | reader
db-119-001-instance-04 | reader
db-119-001-instance-05 | reader
(4 rows)
```
Nell'esempio seguente sono elencate tutte le istanze, il ritardo di ognuna di esse rispetto all'istanza di scrittura e quanto tempo è trascorso dall'ultimo aggiornamento:
```
=> 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
Restituisce una riga per processo del server, mostrando le informazioni relative all’attività corrente di quel processo.
## Sintassi
```
aurora_stat_activity();
```
## Argomenti
Nessuno
## Tipo restituito
Restituisce una riga per processo del server. Oltre alle colonne `pg_stat_activity`, viene aggiunto il seguente campo:
+ planid: identificatore del piano
## Note per l’utilizzo
Una vista supplementare di `pg_stat_activity` che restituisce le stesse colonne con una colonna `plan_id` aggiuntiva che mostra il piano di esecuzione della query corrente.
`aurora_compute_plan_id` deve essere abilitato affinché la vista restituisca un plan\$1id.
Questa funzione è disponibile dalle versioni 14.10, 15.5 di Aurora PostgreSQL e per tutte le altre versioni successive.
## Esempi
La query di esempio riportata di seguito aggrega il carico massimo per query\$1id e 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)
```
Se il piano utilizzato per query\$1id cambia, aurora\$1stat\$1activity riporterà un nuovo plan\$1id.
```
count | query_id | plan_id
-------+----------------------+-------------
10 | -5471422286312252535 | 1602979607
1 | -6907107586630739258 | -1809935983
1 | -2446282393000597155 | -207532066
(3 rows)
```
# aurora\$1stat\$1backend\$1waits
Visualizza le statistiche per l'attività di attesa per un processo di back-end specifico.
## Sintassi
```
aurora_stat_backend_waits(pid)
```
## Argomenti
`pid`: l'ID per il processo di back-end. È possibile ottenere gli ID di processo utilizzando la vista `pg_stat_activity`.
## Tipo restituito
Record SETOF avente le seguenti colonne:
+ `type_id`: un numero che indica il tipo di evento di attesa, ad esempio `1` per un blocco leggero (`LWLock`), `3` per un blocco o `6` per una sessione client. Questi valori diventano significativi quando i risultati di questa funzione vengono abbinati alle colonne della funzione `aurora_stat_wait_type`, come descritto nella sezione [Esempi](#aurora_stat_backend_waits-examples).
+ `event_id`: un numero identificativo per l'evento di attesa. Abbina questo valore alle colonne di `aurora_stat_wait_event` per ottenere nomi significativi per gli eventi.
+ `waits`: conteggio del numero di attese accumulate per l'ID di processo specificato.
+ `wait_time`: tempo di attesa in millisecondi.
## Note per l'utilizzo
È possibile utilizzare questa funzione per analizzare eventi di attesa di back-end (sessione) specifici che si sono verificati dall'apertura di una connessione. Per ottenere informazioni più significative sui nomi e sui tipi di eventi di attesa, è possibile combinare `aurora_stat_wait_type` e `aurora_stat_wait_event`, utilizzando JOIN come mostrato negli esempi.
## Esempi
Questo esempio mostra tutte le attese, tutti i tipi e tutti i nomi di evento per l'ID processo back-end 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
```
Questo esempio mostra i tipi di attesa correnti e cumulativi e gli eventi di attesa per tutte le sessioni attive (`pg_stat_activity state <> 'idle'`) (ma senza la sessione corrente che richiama la funzione (`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
```
Questo esempio mostra il tipo di attesa corrente e i primi tre (3) eventi di attesa cumultativi, nonché gli eventi di attesa per tutte le sessioni attive (`pg_stat_activity state <> 'idle'`) esclusa la sessione corrente (`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` è una vista delle statistiche che mostra informazioni sulle scritture nella cache di Letture ottimizzate.
## Sintassi
```
aurora_stat_bgwriter()
```
## Argomenti
Nessuno
## Tipo restituito
Record SETOF con tutte le colonne `pg_stat_bgwriter` e le seguenti colonne aggiuntive. Per ulteriori informazioni sulle colonne `pg_stat_bgwriter`, consulta [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).
È possibile ripristinare le statistiche per questa funzione utilizzando `pg_stat_reset_shared("bgwriter")`.
+ `orcache_blks_written`: numero totale di blocchi di dati della cache di Letture ottimizzate scritti.
+ `orcache_blk_write_time`: se `track_io_timing` è abilitato, tiene traccia del tempo totale in millisecondi impiegato per scrivere blocchi di dati di file della cache di Letture ottimizzate. Per ulteriori informazioni, consulta [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
## Note per l'utilizzo
Questa funzione è disponibile per le seguenti versioni di Aurora PostgreSQL:
+ 15.4 e versioni successive
+ 14.9 e versioni successive
## Esempi
```
=> select * from aurora_stat_bgwriter();
-[ RECORD 1 ]-----------------+-----------
orcache_blks_written | 246522
orcache_blk_write_time | 339276.404
```
# aurora\$1stat\$1database
Contiene tutte le colonne di pg\$1stat\$1database e aggiunge nuove colonne alla fine.
## Sintassi
```
aurora_stat_database()
```
## Argomenti
Nessuno
## Tipo restituito
Record SETOF con tutte le colonne `pg_stat_database` e le seguenti colonne aggiuntive. Per ulteriori informazioni sulle colonne `pg_stat_database`, consulta [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`: numero totale di blocchi condivisi letti dall'archiviazione Aurora in questo database.
+ `orcache_blks_hit`: numero totale di accessi alla cache di Letture ottimizzate in questo database.
+ `local_blks_read`: numero totale di blocchi locali letti in questo database.
+ `storage_blk_read_time`: se `track_io_timing` è abilitato, tiene traccia del tempo totale impiegato in millisecondi per leggere i blocchi di file di dati dall'archiviazione Aurora altrimenti il valore è zero. Per ulteriori informazioni, consulta [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
+ `local_blk_read_time`: se `track_io_timing` è abilitato, tiene traccia del tempo totale impiegato in millisecondi per leggere i blocchi di file di dati locali, altrimenti il valore è zero. Per ulteriori informazioni, consulta [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
+ `orcache_blk_read_time`: se `track_io_timing` è abilitato, tiene traccia del tempo totale impiegato in millisecondi per leggere i blocchi di file di dati dalla cache di Letture ottimizzate, altrimenti il valore è zero. Per ulteriori informazioni, consulta [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
**Nota**
Il valore di `blks_read` è la somma di `storage_blks_read`, `orcache_blks_hit` e `local_blks_read`.
Il valore di `blk_read_time` è la somma di `storage_blk_read_time`, `orcache_blk_read_time` e `local_blk_read_time`.
## Note per l'utilizzo
Questa funzione è disponibile per le seguenti versioni di Aurora PostgreSQL:
+ 15.4 e versioni successive
+ 14.9 e versioni successive
## Esempi
L'esempio seguente mostra come contiene tutte le colonne `pg_stat_database` e aggiunge 6 nuove colonne alla fine:
```
=> 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
Riporta l'attività cumulativa per ogni tipo di operazione di linguaggio di manipolazione dei dati (DML) su un database in un cluster Aurora PostgreSQL.
## Sintassi
```
aurora_stat_dml_activity(database_oid)
```
## Argomenti
*database\$1oid*
L'ID oggetto (OID) del database nel cluster Aurora PostgreSQL.
## Tipo restituito
Record SETOF
## Note per l'utilizzo
La funzione `aurora_stat_dml_activity` è disponibile solo con Aurora PostgreSQL versione 3.1 compatibile con il motore PostgreSQL 11.6 e versioni successive.
Utilizzare questa funzione sui cluster Aurora PostgreSQL con un gran numero di database per identificare quali database hanno un'attività DML più veloce o più lenta, o entrambi.
La funzione `aurora_stat_dml_activity` restituisce il numero di volte in cui le operazioni sono state eseguite e la latenza cumulativa in microsecondi per le operazioni SELECT, INSERT, UPDATE e DELETE. Il report include solo le operazioni DML riuscite.
È possibile reimpostare questa statistica utilizzando la funzione di accesso alle statistiche PostgreSQL `pg_stat_reset`. È possibile controllare l'ultima volta che questa statistica è stata reimpostata utilizzando la funzione `pg_stat_get_db_stat_reset_time`. Per ulteriori informazioni sulle funzioni di accesso alle statistiche PostgreSQL, consulta [Raccolta di statistiche](https://www.postgresql.org/docs/9.1/monitoring-stats.html) nella documentazione di PostgreSQL.
## Esempi
L'esempio seguente mostra come eseguire il report delle statistiche di attività DML per il database connesso.
```
––Define the oid variable from connected database by using \gset
=> SELECT oid,
datname
FROM pg_database
WHERE datname=(select current_database()) \gset
=> SELECT *
FROM aurora_stat_dml_activity(:oid);
select_count | select_latency_microsecs | insert_count | insert_latency_microsecs | update_count | update_latency_microsecs | delete_count | delete_latency_microsecs
--------------+--------------------------+--------------+--------------------------+--------------+--------------------------+--------------+--------------------------
178957 | 66684115 | 171065 | 28876649 | 519538 | 1454579206167 | 1 | 53027
–– Showing the same results with expanded display on
=> SELECT *
FROM aurora_stat_dml_activity(:oid);
-[ RECORD 1 ]------------+--------------
select_count | 178957
select_latency_microsecs | 66684115
insert_count | 171065
insert_latency_microsecs | 28876649
update_count | 519538
update_latency_microsecs | 1454579206167
delete_count | 1
delete_latency_microsecs | 53027
```
L'esempio seguente mostra le statistiche di attività DML per tutti i database nel cluster Aurora PostgreSQL. Questo cluster dispone di due database, `postgres` e `mydb`. L'elenco separato da virgole corrisponde ai campi `select_count`, `select_latency_microsecs`, `insert_count`, `insert_latency_microsecs`, `update_count`, `update_latency_microsecs`, `delete_count` e `delete_latency_microsecs`.
Aurora PostgreSQL crea e utilizza un database di sistema denominato `rdsadmin` per supportare operazioni amministrative quali backup, ripristini, controlli di integrità, replica e così via. Queste operazioni DML non hanno alcun impatto sul cluster Aurora PostgreSQL.
```
=> SELECT oid,
datname,
aurora_stat_dml_activity(oid)
FROM pg_database;
oid | datname | aurora_stat_dml_activity
-------+----------------+-----------------------------------------------------------------
14006 | template0 | (,,,,,,,)
16384 | rdsadmin | (2346623,1211703821,4297518,817184554,0,0,0,0)
1 | template1 | (,,,,,,,)
14007 | postgres | (178961,66716329,171065,28876649,519538,1454579206167,1,53027)
16401 | mydb | (200246,64302436,200036,107101855,600000,83659417514,0,0)
```
Nell'esempio seguente vengono illustrate le statistiche di attività DML per tutti i database, organizzate in colonne per una migliore leggibilità.
```
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
```
Nell'esempio seguente viene illustrata la latenza cumulativa media (latenza cumulativa divisa per conteggio) per ogni operazione DML per il database con 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
Ottiene la latenza di commit cumulativa in microsecondi per i database Aurora PostgreSQL. La *Latenza commit* viene misurata come il tempo che intercorre tra il momento in cui un client invia una richiesta di commit e il momento in cui riceve la conferma di commit.
## Sintassi
```
aurora_stat_get_db_commit_latency(database_oid)
```
## Argomenti
*database\$1oid*
L'ID oggetto (OID) del database Aurora PostgreSQL.
## Tipo restituito
Record SETOF
## Note per l'utilizzo
Amazon CloudWatch utilizza questa funzione per calcolare la latenza media di commit. Per ulteriori informazioni sui parametri di Amazon CloudWatch e sulla risoluzione dei problemi di elevata latenza di commit, consulta [Visualizzazione delle metriche nella console Amazon RDS](USER_Monitoring.md) e [Prendere decisioni migliori su Amazon RDS con i parametri di Amazon CloudWatch](https://aws.amazon.com/blogs/database/making-better-decisions-about-amazon-rds-with-amazon-cloudwatch-metrics/).
È possibile reimpostare questa statistica utilizzando la funzione di accesso alle statistiche PostgreSQL `pg_stat_reset`. È possibile controllare l'ultima volta che questa statistica è stata reimpostata utilizzando la funzione `pg_stat_get_db_stat_reset_time`. Per ulteriori informazioni sulle funzioni di accesso alle statistiche PostgreSQL, consulta [Raccolta di statistiche](https://www.postgresql.org/docs/9.1/monitoring-stats.html) nella documentazione di PostgreSQL.
## Esempi
Nell'esempio seguente viene ottenuta la latenza di commit cumulativa per ogni database nel cluster `pg_database`.
```
=> SELECT oid,
datname,
aurora_stat_get_db_commit_latency(oid)
FROM pg_database;
oid | datname | aurora_stat_get_db_commit_latency
-------+----------------+-----------------------------------
14006 | template0 | 0
16384 | rdsadmin | 654387789
1 | template1 | 0
16401 | mydb | 229556
69768 | postgres | 22011
```
Nell'esempio seguente viene ottenuta la latenza di commit cumulativa per il database attualmente connesso. Prima di chiamare la funzione `aurora_stat_get_db_commit_latency`, l'esempio utilizza `\gset` per definire una variabile per `oid` e imposta il suo valore dal database connesso.
```
––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
```
Nell'esempio seguente viene ottenuta la latenza di commit cumulativa per il database `mydb` nel cluster `pg_database`. Quindi, reimposta questa statistica utilizzando la funzione `pg_stat_reset` e mostra i risultati. Infine, utilizza la funzione `pg_stat_get_db_stat_reset_time` per controllare l'ultima volta che questa statistica è stata reimpostata.
```
=> 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
Mostra l'utilizzo della cache WAL (write-ahead log) logica per slot.
## Sintassi
```
SELECT * FROM aurora_stat_logical_wal_cache()
```
## Argomenti
Nessuno
## Tipo restituito
Record SETOF avente le seguenti colonne:
+ `name`: il nome dello slot di replica.
+ `active_pid`: ID del processo walsender.
+ `cache_hit`: il numero totale di riscontri della cache wal dall'ultimo ripristino.
+ `cache_miss`: il numero totale di riscontri mancati della cache wal dall'ultimo ripristino.
+ `blks_read`: il numero totale di richieste di lettura della cache wal.
+ `hit_rate`: la percentuale di riscontri nella cache WAL (cache\$1hit/blks\$1read).
+ `last_reset_timestamp`: data e ora dell'ultimo ripristino del contatore.
## Note per l’utilizzo
Questa funzione è disponibile per le seguenti versioni di Aurora PostgreSQL.
+ 15.2 e tutte le versioni successive
+ 14.7 e versioni successive
+ 13.8 e versioni successive
+ 12.12 e versioni successive
+ 11.17 e versioni successive
## Esempi
L'esempio seguente mostra due slot di replica con una sola funzione `aurora_stat_logical_wal_cache`attiva.
```
=> 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
Segnala l'utilizzo del contesto della memoria per ciascun processo PostgreSQL.
## Sintassi
```
aurora_stat_memctx_usage()
```
## Argomenti
Nessuno
## Tipo restituito
Record SETOF avente le seguenti colonne:
+ `pid`: l'ID del processo.
+ `name`: il nome del contesto della memoria.
+ `allocated`: il numero di byte ottenuti dal sottosistema della memoria sottostante mediante il contesto della memoria.
+ `used`: il numero di byte vincolati per i client del contesto della memoria.
+ `instances`: il numero di contesti di questo tipo attualmente esistenti.
## Note per l'utilizzo
Questa funzione visualizza l'utilizzo del contesto della memoria per ciascun processo PostgreSQL. Alcuni processi sono etichettati `anonymous`. I processi non sono esposti perché contengono parole chiave limitate.
Questa funzione è disponibile a partire dalle seguenti versioni di Aurora PostgreSQL:
+ 15.3 o versioni successive alla 15
+ 14.8 o versioni successive alla 14
+ 13.11 o versioni successive alla 13
+ 12.15 e versioni successive alla 12
+ 11.20 e versioni successive alla 11
## Esempi
Nell'esempio seguente vengono mostrati i risultati della chiamata della funzione `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)
```
Alcune parole chiave limitate verranno nascoste e l'aspetto dell'output sarà il seguente:
```
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
Questa funzione mostra le statistiche relative alla cache a più livelli.
## Sintassi
```
aurora_stat_optimized_reads_cache()
```
## Argomenti
Nessuno
## Tipo restituito
Record SETOF avente le seguenti colonne:
+ `total_size`: dimensione totale della cache di Letture ottimizzate.
+ `used_size`: dimensione della pagina utilizzata nella cache di Letture ottimizzate.
## Note per l'utilizzo
Questa funzione è disponibile per le seguenti versioni di Aurora PostgreSQL:
+ 15.4 e versioni successive
+ 14.9 e versioni successive
## Esempi
L'esempio seguente mostra l'output di un'istanza 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
Restituisce una riga per ogni piano di esecuzione monitorato.
## Sintassi
```
aurora_stat_plans(
showtext
)
```
## Argomenti
+ showtext: mostra il testo della query e del piano. I valori validi sono NULL, true o false. True mostrerà il testo della query e del piano.
## Tipo restituito
Restituisce una riga per ogni piano monitorato che contiene tutte le colonne di `aurora_stat_statements` e le seguenti colonne aggiuntive.
+ planid: identificatore del piano
+ explain\$1plan: spiega il testo del piano
+ plan\$1type:
+ `no plan`: nessun piano è stato acquisito
+ `estimate`: piano acquisito con costi stimati
+ `actual`: piano acquisito con EXPLAIN ANALYZE
+ plan\$1captured\$1time: ultima acquisizione di un piano
## Note per l’utilizzo
`aurora_compute_plan_id` deve essere abilitato e `pg_stat_statements` deve essere in `shared_preload_libraries` affinché i piani possano essere monitorati.
Il numero di piani disponibili è controllato dal valore impostato nel parametro `pg_stat_statements.max`. Quando `aurora_compute_plan_id` è abilitato, è possibile monitorare i piani fino al valore specificato in `aurora_stat_plans`.
Questa funzione è disponibile dalle versioni 14.10, 15.5 di Aurora PostgreSQL e per tutte le altre versioni successive.
## Esempi
Nell’esempio seguente, vengono acquisiti i due piani relativi all’identificatore di query -5471422286312252535 e le statistiche delle istruzioni vengono monitorate dal 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
Reimposta il contatore per la cache wal logica.
## Sintassi
Per reimpostare uno slot specifico
```
SELECT * FROM aurora_stat_reset_wal_cache('slot_name')
```
Per ripristinare tutti gli slot
```
SELECT * FROM aurora_stat_reset_wal_cache(NULL)
```
## Argomenti
`NULL` o `slot_name`
## Tipo restituito
Messaggio di stato, stringa di testo
+ Reimposta il contatore logico della cache wal. Messaggio di esito positivo. Questo testo viene restituito quando la funzione ha esito positivo.
+ Lo slot di replica non è stato trovato Riprova. Messaggio di errore Questo testo viene restituito quando la funzione non riesce.
## Note per l'utilizzo
Questa funzione è disponibile per le seguenti versioni.
+ Aurora PostgreSQL 14.5 e versioni successive
+ Aurora PostgreSQL 13.8 e versioni successive
+ Aurora PostgreSQL 12.12 e versioni successive
+ Aurora PostgreSQL 11.7 e versioni successive
## Esempi
L'esempio seguente utilizza la funzione `aurora_stat_reset_wal_cache` per reimpostare uno slot denominato `test_results` e quindi tenta di reimpostare uno slot che non esiste.
```
=> 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
Riporta l’utilizzo delle risorse in tempo reale, che comprende le metriche delle risorse backend e l’utilizzo della CPU per tutti i processi backend Aurora PostgreSQL.
## Sintassi
```
aurora_stat_resource_usage()
```
## Argomenti
Nessuno
## Tipo restituito
Record SETOF con colonne:
+ pid: identificatore del processo
+ allocated\$1memory: memoria totale allocata dal processo in byte
+ used\$1memory: memoria effettivamente utilizzata per processo in byte
+ cpu\$1usage\$1percent: percentuale di utilizzo della CPU del processo
## Note per l'utilizzo
Questa funzione mostra l’utilizzo delle risorse backend per ogni processo backend Aurora PostgreSQL.
Questa funzione è disponibile a partire dalle seguenti versioni di Aurora PostgreSQL:
+ Aurora PostgreSQL 17.5 e versioni 17 successive
+ Aurora PostgreSQL 16.9 e versioni 16 successive
+ Aurora PostgreSQL 15.13 e versioni 15 successive
+ Aurora PostgreSQL 14.18 e versioni 14 successive
+ Aurora PostgreSQL 13.21 e versioni 13 successive
## Esempi
Il seguente esempio mostra l’output della funzione `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
Mostra tutte le colonne `pg_stat_statements` e ne aggiunge altre alla fine.
## Sintassi
```
aurora_stat_statements(showtext boolean)
```
## Argomenti
*showtext boolean*
## Tipo restituito
Record SETOF con tutte le colonne `pg_stat_statements` e le seguenti colonne aggiuntive. Per ulteriori informazioni sulle colonne `pg_stat_statements`, consulta [https://www.postgresql.org/docs/current/pgstatstatements.html](https://www.postgresql.org/docs/current/pgstatstatements.html).
È possibile ripristinare le statistiche per questa funzione utilizzando `pg_stat_statements_reset()`.
+ `storage_blks_read`: numero totale di blocchi condivisi letti dall'archiviazione Aurora con questa istruzione.
+ `orcache_blks_hit`: numero totale di accessi alla cache di Letture ottimizzate con questa istruzione.
+ `storage_blk_read_time`: se `track_io_timing` è abilitato, tiene traccia del tempo totale, in millisecondi, impiegato dall’istruzione per leggere i blocchi condivisi dall’archiviazione Aurora, altrimenti il valore è zero. Per ulteriori informazioni, consulta [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
+ `local_blk_read_time`: se `track_io_timing` è abilitato, tiene traccia del tempo totale, in millisecondi, impiegato dall’istruzione per leggere i blocchi locali, altrimenti il valore è zero. Per ulteriori informazioni, consulta [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
+ `orcache_blk_read_time`: se `track_io_timing` è abilitato, tiene traccia del tempo totale, in secondi, impiegato dall’istruzione per leggere i blocchi condivisi dalla cache di letture ottimizzate, altrimenti il valore è zero. Per ulteriori informazioni, consulta [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING).
+ `total_plan_peakmem`: somma totale dei valori di memoria di picco durante la fase di pianificazione per tutte le chiamate a questa istruzione. Per visualizzare la memoria di picco media durante la pianificazione dell’istruzione, dividi questo valore per il numero di chiamate.
+ `min_plan_peakmem`: il valore di memoria di picco più basso rilevato durante la pianificazione di tutte le chiamate a questa istruzione.
+ `max_plan_peakmem`: il valore di memoria di picco più alto durante la pianificazione di tutte le chiamate a questa istruzione.
+ `total_exec_peakmem`: somma totale dei valori di memoria di picco durante la fase di esecuzione per tutte le chiamate a questa istruzione. Per visualizzare la memoria di picco media durante l’esecuzione dell’istruzione, dividi questo valore per il numero di chiamate.
+ `min_exec_peakmem`: il valore di memoria di picco più basso, in byte, rilevato durante l’esecuzione di tutte le chiamate a questa istruzione.
+ `max_exec_peakmem`: il valore di memoria di picco più alto, in byte, rilevato durante l’esecuzione di tutte le chiamate a questa istruzione.
**Nota**
`total_plan_peakmen`, `min_plan_peakmem` e `max_plan_peakmem` vengono monitorati solo quando l’impostazione `pg_stat_statements.track_planning` è attivata.
## Note per l'utilizzo
Per utilizzare la funzione aurora\$1stat\$1statements(), è necessario includere l’estensione `pg_stat_statements` nel parametro `shared_preload_libraries`.
Questa funzione è disponibile per le seguenti versioni di Aurora PostgreSQL:
+ 15.4 e versioni successive
+ 14.9 e versioni successive
Le colonne che mostrano i picchi di memoria sono disponibili nelle seguenti versioni:
+ 16.3 e versioni successive
+ 15.7 e versioni successive
+ 14.12 e versioni successive
## Esempi
L’esempio seguente mostra come contiene tutte le colonne pg\$1stat\$1statements e aggiunge 11 nuove colonne alla fine:
```
=> 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
Segnala le informazioni sugli eventi di attesa per l'istanza database di Aurora PostgreSQL.
## Sintassi
```
aurora_stat_system_waits()
```
## Argomenti
Nessuno
## Tipo restituito
Record SETOF
## Note per l'utilizzo
Questa funzione restituisce il numero cumulativo di attese e tempo di attesa cumulativo per ogni evento di attesa generato dall'istanza database a cui si è attualmente connessi.
Il recordset restituito include i seguenti campi:
+ `type_id`: ID del tipo di evento di attesa.
+ `event_id`: ID dell'evento di attesa.
+ `waits`: numero di volte in cui si è verificato l'evento di attesa.
+ `wait_time`: tempo di attesa totale in microsecondi per questo evento.
Le statistiche restituite da questa funzione vengono reimpostate al riavvio di un'istanza database.
## Esempi
Nell'esempio seguente vengono mostrati i risultati della chiamata alla funzione `aurora_stat_system_waits`.
```
=> SELECT *
FROM aurora_stat_system_waits();
type_id | event_id | waits | wait_time
---------+-----------+-----------+--------------
1 | 16777219 | 11 | 12864
1 | 16777220 | 501 | 174473
1 | 16777270 | 53171 | 23641847
1 | 16777271 | 23 | 319668
1 | 16777274 | 60 | 12759
.
.
.
10 | 167772231 | 204596 | 790945212
10 | 167772232 | 2 | 47729
10 | 167772234 | 1 | 888
10 | 167772235 | 2 | 64
```
L'esempio seguente mostra come puoi utilizzare questa funzione insieme a `aurora_stat_wait_event` e `aurora_stat_wait_type` per produrre risultati più leggibili.
```
=> 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
Elenca tutti gli eventi di attesa supportati per Aurora PostgreSQL. Per ulteriori informazioni sulla sicurezza con Aurora PostgreSQL, consulta [Eventi di attesa Amazon Aurora PostgreSQL](AuroraPostgreSQL.Reference.Waitevents.md).
## Sintassi
```
aurora_stat_wait_event()
```
## Argomenti
Nessuno
## Tipo restituito
Record SETOF avente le seguenti colonne:
+ type\$1id: ID del tipo di evento di attesa.
+ event\$1id: ID dell'evento di attesa.
+ type\$1name: nome del tipo di attesa
+ event\$1name: nome dell’evento di attesa
## Note per l'utilizzo
Per visualizzare i nomi degli eventi con tipi di evento anziché ID, utilizzare questa funzione insieme ad altre funzioni, ad esempio `aurora_stat_wait_type` e `aurora_stat_system_waits`. I nomi degli eventi di attesa restituiti da questa funzione sono gli stessi di quelli restituiti dalla funzione `aurora_wait_report`.
## Esempi
Nell'esempio seguente vengono mostrati i risultati della chiamata alla funzione `aurora_stat_wait_event`.
```
=> SELECT *
FROM aurora_stat_wait_event();
type_id | event_id | event_name
---------+-----------+-------------------------------------------
1 | 16777216 |
1 | 16777217 | ShmemIndexLock
1 | 16777218 | OidGenLock
1 | 16777219 | XidGenLock
.
.
.
9 | 150994945 | PgSleep
9 | 150994946 | RecoveryApplyDelay
10 | 167772160 | BufFileRead
10 | 167772161 | BufFileWrite
10 | 167772162 | ControlFileRead
.
.
.
10 | 167772226 | WALInitWrite
10 | 167772227 | WALRead
10 | 167772228 | WALSync
10 | 167772229 | WALSyncMethodAssign
10 | 167772230 | WALWrite
10 | 167772231 | XactSync
.
.
.
11 | 184549377 | LsnAllocate
```
L'esempio seguente unisce `aurora_stat_wait_type` e `aurora_stat_wait_event` per restituire nomi di tipo e nomi di eventi per una migliore leggibilità.
```
=> 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
Elenca tutti i tipi di attesa supportati per Aurora PostgreSQL.
## Sintassi
```
aurora_stat_wait_type()
```
## Argomenti
Nessuno
## Tipo restituito
Record SETOF avente le seguenti colonne:
+ type\$1id: ID del tipo di evento di attesa.
+ type\$1name: nome del tipo di attesa
## Note per l'utilizzo
Per visualizzare i nomi degli eventi di attesa con tipi di eventi di attesa anziché ID, utilizzare questa funzione insieme ad altre funzioni come `aurora_stat_wait_event` e `aurora_stat_system_waits`. I nomi dei tipi di attesa restituiti da questa funzione sono gli stessi di quelli restituiti dalla funzione `aurora_wait_report`.
## Esempi
Nell'esempio seguente vengono mostrati i risultati della chiamata alla funzione `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
Restituisce il valore di stringa del numero di versione di Amazon Aurora PostgreSQL-Compatible Edition.
## Sintassi
```
aurora_version()
```
## Argomenti
Nessuno
## Tipo restituito
Stringa CHAR o VARCHAR
## Note per l'utilizzo
Questa funzione visualizza la versione del motore di database di Amazon Aurora PostgreSQL-Compatible Edition. Il numero di versione viene restituito come stringa formattata come *principale*.*secondaria*.*patch*. Per ulteriori informazioni sui numeri di versione del motore Aurora PostgreSQL, consulta [Numero versione Aurora](AuroraPostgreSQL.Updates.md#AuroraPostgreSQL.Updates.Versions.AuroraNumber)
Puoi scegliere quando applicare aggiornamenti di versione secondaria impostando la finestra di manutenzione per il cluster database Aurora PostgreSQL. Per scoprire come fare, consulta [Manutenzione di un cluster di database Amazon Aurora](USER_UpgradeDBInstance.Maintenance.md).
A partire dal rilascio di PostgreSQL versioni 13.3, 12.8, 11.13, 10.18 e per tutte le altre versioni successive, i numeri di versione di Aurora seguono i numeri di versione di PostgreSQL. Per ulteriori informazioni su questa versione, consulta [Aggiornamenti di Amazon Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Updates.html) nelle *Note di rilascio di Aurora PostgreSQL*.
## Esempi
L'esempio seguente mostra i risultati della chiamata della funzione `aurora_version` su un cluster database Aurora PostgreSQL in esecuzione prima su [PostgreSQL 12.7, Aurora PostgreSQL versione 4.2](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Updates.html#AuroraPostgreSQL.Updates.20180305.42) e poi su [Aurora PostgreSQL versione 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
```
Questo esempio mostra varie opzioni di utilizzo della funzione per ottenere maggiori dettagli sulla versione di Aurora PostgreSQL. In questo esempio Aurora presenta un numero di versione distinto rispetto a 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)
```
Nell'esempio successivo, la funzione viene utilizzata con le stesse opzioni dell'esempio precedente. In questo esempio il numero di versione di Aurora non è distinto rispetto al numero di versione di 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
Restituisce il numero di sequenza di log (LSN) utilizzato per identificare l'inizio di un record nel flusso WAL (write-ahead log) logico del volume del cluster Aurora.
## Sintassi
```
aurora_volume_logical_start_lsn()
```
## Argomenti
Nessuno
## Tipo restituito
`pg_lsn`
## Note per l'utilizzo
Questa funzione identifica l'inizio del record nel flusso WAL logico per un determinato volume del cluster Aurora. È possibile utilizzare questa funzione durante l'aggiornamento della versione principale utilizzando la replica logica e la clonazione rapida Aurora per determinare il numero di sequenza di log in corrispondenza del quale viene eseguito uno snapshot o un clone del database. È quindi possibile utilizzare la replica logica per trasmettere continuamente i record di dati più recenti dopo il numero di sequenza di log e sincronizzare le modifiche da editore a sottoscrittore.
Per ulteriori informazioni sull'utilizzo della replica logica per l'aggiornamento di una versione principale, consulta [Utilizzo della replica logica per eseguire l'aggiornamento a una versione principale per Aurora PostgreSQL](AuroraPostgreSQL.MajorVersionUpgrade.md).
Questa funzione è disponibile per le seguenti versioni di Aurora PostgreSQL:
+ 15.2 o versioni successive alla 15
+ 14.3 o versioni successive alla 14
+ 13.6 o versioni successive alla 13
+ 12.10 e versioni successive alla 12
+ 11.15 e versioni successive alla 11
+ 10.20 e versioni successive alla 10
## Esempi
È possibile ottenere il numero di sequenza di log utilizzando la seguente query:
```
postgres=> SELECT aurora_volume_logical_start_lsn();
aurora_volume_logical_start_lsn
---------------
0/402E2F0
(1 row)
```
# aurora\$1wait\$1report
Questa funzione mostra l'attività dell'evento di attesa durante un periodo di tempo.
## Sintassi
```
aurora_wait_report([time])
```
## Argomenti
*tempo (facoltativo) *
Il tempo in secondi. Il valore predefinito è 10 secondi.
## Tipo restituito
Record SETOF avente le seguenti colonne:
+ type\$1name: nome del tipo di attesa
+ event\$1name: nome dell’evento di attesa
+ wait: numero di attese
+ wait\$1time: tempo di attesa in millisecondi
+ ms\$1per\$1wait: durata media di un’attesa in millisecondi
+ waits\$1per\$1xact: media delle attese per ogni transazione
+ ms\$1per\$1xact: durata media di una transizione in millisecondi
## Note per l'utilizzo
Questa funzione è disponibile a partire da Aurora PostgreSQL versione 1.1 compatibile con PostgreSQL 9.6.6 e versioni successive.
Per utilizzare questa funzione è necessario innanzitutto creare l’estensione `aurora_stat_utils` Aurora PostgreSQL, nel modo seguente:
```
=> CREATE extension aurora_stat_utils;
CREATE EXTENSION
```
Per ulteriori informazioni sulle versioni dell'estensione Aurora PostgreSQL disponibili, consulta [Versioni delle estensioni per Amazon Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Extensions.html) in *Note di rilascio di Aurora PostgreSQL*.
Questa funzione calcola gli eventi di attesa a livello di istanza confrontando i dati statistici di due snapshot della funzione aurora\$1stat\$1system\$1waits () e di pg\$1stat\$1database, acquisite dalla vista delle statistiche di PostgreSQL.
Per ulteriori informazioni su `aurora_stat_system_waits()` e `pg_stat_database`, consulta [Raccolta di statistiche](https://www.postgresql.org/docs/current/monitoring-stats.html#PG-STAT-DATABASE-VIEW) nella *documentazione di PostgreSQL*.
Quando è in esecuzione, questa funzione acquisisce una snapshot iniziale, attende il numero di secondi specificato e acquisisce una seconda snapshot. La funzione confronta le due snapshot e restituisce la differenza. Questa differenza rappresenta l'attività dell'istanza in quell'intervallo di tempo.
Sull'istanza di scrittura, la funzione visualizza anche il numero di transazioni di cui è stato eseguito il commit e il TPS (transazioni al secondo). Questa funzione restituisce informazioni a livello di istanza e include tutti i database sull'istanza.
## Esempi
Questo esempio mostra come creare l’estensione aurora\$1stat\$1utils per poter utilizzare la funzione aurora\$1wait\$1report.
```
=> CREATE extension aurora_stat_utils;
CREATE EXTENSION
```
Questo esempio mostra come controllare il report delle attese per 10 secondi.
```
=> 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
```
Questo esempio mostra come controllare il report delle attese per 60 secondi.
```
=> 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
```
# Amazon Aurora PostgreSQL parametri
La gestione del cluster di database di Amazon Aurora è uguale a quella delle istanze database Amazon RDS, ovvero utilizza i parametri di un gruppo parametri del database. Tuttavia, Amazon Aurora si differenzia da Amazon RDS in quanto un cluster DB Aurora ha più istanze DB. Alcuni parametri che utilizzi per gestire il cluster DB Amazon Aurora DB si applicano a tutto il cluster, mentre altri si applicano soltanto a una specifica istanza database nel cluster DB, come segue.
+ **Gruppo di parametri del cluster DB**: un gruppo di parametri del cluster DB contiene il set di parametri di configurazione del motore applicabili in tutto il cluster DB Aurora. Ad esempio, la gestione della cache del cluster è una caratteristica di un cluster DB Aurora controllato dal parametro `apg_ccm_enabled` che fa parte del gruppo di parametri del cluster di database. Il gruppo di parametri del cluster DB contiene anche le impostazioni predefinite per il gruppo parametri del database per le istanze database che costituiscono il cluster.
+ **Gruppo parametri del database**: un gruppo di parametri del database è l'insieme di valori di configurazione del motore che si applicano a un'istanza database specifica di quel tipo di motore. I gruppi parametri del database per il motore PostgreSQL DB vengono utilizzati da un'istanza database RDS per PostgreSQL e da un cluster database Aurora PostgreSQL. Queste impostazioni di configurazione si applicano alle proprietà che possono variare tra le istanze database all’interno di un cluster Aurora, ad esempio le dimensioni dei buffer di memoria.
I parametri a livello di cluster sono gestiti nei gruppi di parametri del cluster database. I parametri a livello di istanza sono gestiti nei gruppi parametri del database. Puoi gestire i parametri utilizzando la console Amazon RDS AWS CLI, o l'API Amazon RDS. Sono disponibili comandi separati per la gestione dei parametri a livello di cluster e a livello di istanza.
+ [Per gestire i parametri a livello di cluster in un gruppo di parametri del cluster DB, usa il comando -group. modify-db-cluster-parameter](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster-parameter-group.html) AWS CLI
+ Per gestire i parametri a livello di istanza in un gruppo di parametri DB per un'istanza DB in un cluster DB, usa il comando. [modify-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-parameter-group.html) AWS CLI
*Per ulteriori informazioni AWS CLI, consulta Using the AWS CLI nella [Guida per l'](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-using.html)AWS Command Line Interface utente.*
Per ulteriori informazioni sui gruppi di parametri, consultare [Gruppi di parametri per Amazon Aurora](USER_WorkingWithParamGroups.md).
## Visualizzazione del cluster di database Aurora PostgreSQL e dei parametri del database
È possibile visualizzare tutti i gruppi di parametri di default disponibili per le istanze DB Amazon RDS for PostgreSQL e per i cluster DB Aurora PostgreSQL nella Console di gestione AWS. I gruppi di parametri predefiniti per tutti i motori DB e i tipi e le versioni di cluster DB sono elencati per ogni AWS regione. Vengono elencati anche tutti i gruppi di parametri personalizzati.
Invece di visualizzarli in Console di gestione AWS, puoi anche elencare i parametri contenuti nei gruppi di parametri del cluster DB e nei gruppi di parametri DB utilizzando AWS CLI o l'API Amazon RDS. Ad esempio, per elencare i parametri in un gruppo di parametri del cluster DB, usa il [describe-db-cluster-parameters](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-cluster-parameters.html) AWS CLI comando seguente:
```
aws rds describe-db-cluster-parameters --db-cluster-parameter-group-name default.aurora-postgresql12
```
Il comando restituisce descrizioni JSON dettagliate di ciascun parametro. Per ridurre la quantità di informazioni restituite, è possibile specificare le preferenze utilizzando l'opzione `--query`. Ad esempio, puoi ottenere il nome del parametro, la relativa descrizione e i valori consentiti per il gruppo di parametri del cluster di database Aurora PostgreSQL 12 di default come segue:
Per Linux, macOS o Unix:
```
aws rds describe-db-cluster-parameters --db-cluster-parameter-group-name default.aurora-postgresql12 \
--query 'Parameters[].[{ParameterName:ParameterName,Description:Description,ApplyType:ApplyType,AllowedValues:AllowedValues}]'
```
Per Windows:
```
aws rds describe-db-cluster-parameters --db-cluster-parameter-group-name default.aurora-postgresql12 ^
--query "Parameters[].[{ParameterName:ParameterName,Description:Description,ApplyType:ApplyType,AllowedValues:AllowedValues}]"
```
Un gruppo di parametri del cluster di DB Aurora include il gruppo di parametri dell'istanza database e i valori di default per un determinato motore di Aurora DB. È possibile ottenere l'elenco dei parametri DB dallo stesso gruppo di parametri predefinito Aurora PostgreSQL utilizzando il comando illustrato di seguito. [describe-db-parameters](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-parameters.html) AWS CLI
Per Linux, macOS o Unix:
```
aws rds describe-db-parameters --db-parameter-group-name default.aurora-postgresql12 \
--query 'Parameters[].[{ParameterName:ParameterName,Description:Description,ApplyType:ApplyType,AllowedValues:AllowedValues}]'
```
Per Windows:
```
aws rds describe-db-parameters --db-parameter-group-name default.aurora-postgresql12 ^
--query "Parameters[].[{ParameterName:ParameterName,Description:Description,ApplyType:ApplyType,AllowedValues:AllowedValues}]"
```
I comandi precedenti restituiscono elenchi di parametri dal cluster di database o dal gruppo parametri del database con descrizioni e altri dettagli specificati nella query. Di seguito è riportata una risposta di esempio:
```
[
[
{
"ParameterName": "apg_enable_batch_mode_function_execution",
"ApplyType": "dynamic",
"Description": "Enables batch-mode functions to process sets of rows at a time.",
"AllowedValues": "0,1"
}
],
[
{
"ParameterName": "apg_enable_correlated_any_transform",
"ApplyType": "dynamic",
"Description": "Enables the planner to transform correlated ANY Sublink (IN/NOT IN subquery) to JOIN when possible.",
"AllowedValues": "0,1"
}
],...
```
Di seguito sono riportate le tabelle contenenti i valori per il parametro del cluster database di default e il parametro database per Aurora PostgreSQL versione 14.
## Parametri a livello di cluster Aurora PostgreSQL
Puoi visualizzare i parametri a livello di cluster disponibili per una versione specifica di Aurora PostgreSQL utilizzando la AWS console di gestione, la CLI o l'API Amazon RDS. AWS Per informazioni sulla visualizzazione dei parametri in un gruppo di parametri del cluster database Aurora PostgreSQL nella console RDS, consultare [Visualizzazione dei valori dei parametri per un gruppo di parametri del cluster DB in Amazon Aurora](USER_WorkingWithParamGroups.ViewingCluster.md).
Alcuni parametri a livello di cluster non sono disponibili in tutte le versioni e alcuni sono obsoleti. Per informazioni sulla visualizzazione dei parametri di una versione specifica di Aurora PostgreSQL, consultare [Visualizzazione del cluster di database Aurora PostgreSQL e dei parametri del database](#AuroraPostgreSQL.Reference.ParameterGroups-viewing-parameters).
Ad esempio, nella tabella seguente sono elencati i parametri disponibili nel gruppo di parametri del cluster database di default per Aurora PostgreSQL versione 14. Se si crea un cluster di database Aurora PostgreSQL senza specificare il proprio gruppo parametri del database personalizzato, il cluster di database viene creato utilizzando il gruppo di parametri cluster di database Aurora predefinito per la versione scelta, ad esempio `default.aurora-postgresql14`, `default.aurora-postgresql13` e così via.
Per un elenco dei parametri dell'istanza database per lo stesso gruppo di parametri del cluster database, consulta [Parametri a livello di istanza Aurora PostgreSQL](#AuroraPostgreSQL.Reference.Parameters.Instance).
| Nome del parametro | Description | Predefinita |
| --- | --- | --- |
| ansi\$1constraint\$1trigger\$1ordering | Modifica l'ordine di attivazione dei trigger di vincolo in modo che siano compatibili con lo standard ANSI SQL. | – |
| ansi\$1force\$1foreign\$1key\$1checks | Assicurati che le operazioni referenziali come l'eliminazione a cascata o l'aggiornamento a cascata si verifichino sempre indipendentemente dai vari contesti di attivazione esistenti per l'operazione. | – |
| ansi\$1qualified\$1update\$1set\$1target | Tabella di supporto e qualificatori dello schema nelle istruzioni UPDATE ... SET. | – |
| apg\$1ccm\$1enabled | Abilita o disabilita la gestione della cache del cluster per il cluster. | – |
| apg\$1enable\$1batch\$1mode\$1function\$1execution | Consente alle funzioni in modalità batch di elaborare serie di righe in una volta. | – |
| apg\$1enable\$1correlated\$1any\$1transform | Consente al pianificatore di trasformare il link secondario ANY (sottoquery IN/NOT IN) in JOIN quando possibile. | – |
| apg\$1enable\$1function\$1migration | Consente al pianificatore di migrare le funzioni scalari idonee alla clausola FROM. | – |
| apg\$1enable\$1not\$1in\$1transform | Consente al pianificatore di trasformare la query secondaria NOT IN in ANTI JOIN quando possibile. | – |
| apg\$1enable\$1remove\$1redundant\$1inner\$1joins | Consente al pianificatore di rimuovere i join interni ridondanti. | – |
| apg\$1enable\$1semijoin\$1push\$1down | Consente l’utilizzo di filtri semijoin per gli hash join. | – |
| apg\$1plan\$1mgmt.capture\$1plan\$1baselines | Modalità baseline di acquisizione del piano. manual (manuale): abilita l'acquisizione del piano per qualsiasi istruzione SQL, off: disabilita l'acquisizione del piano, automatic (automatica): abilita l'acquisizione del piano per le istruzioni in pg\$1stat\$1statements che soddisfano i criteri di idoneità. | off |
| apg\$1plan\$1mgmt.max\$1databases | Imposta il numero massimo di database che possono gestire le query utilizzando apg\$1plan\$1mgmt. | 10 |
| apg\$1plan\$1mgmt.max\$1plans | Imposta il numero massimo di piani che possono essere memorizzati nella cache da apg\$1plan\$1mgmt. | 10000 |
| apg\$1plan\$1mgmt.plan\$1retention\$1period | Numero massimo di giorni dall’ultimo utilizzo di un piano prima che venga eliminato automaticamente. | 32 |
| apg\$1plan\$1mgmt.unapproved\$1plan\$1execution\$1threshold | Costo totale stimato del piano al di sotto del quale verrà eseguito un piano non approvato. | 0 |
| apg\$1plan\$1mgmt.use\$1plan\$1baselines | Utilizzare solo piani approvati o fissi per le istruzioni gestite. | false |
| application\$1name | Imposta il nome dell’applicazione da riportare nelle statistiche e nei registri. | – |
| array\$1nulls | Abilita l'inserimento di elementi NULL negli array. | – |
| aurora\$1compute\$1plan\$1id | Monitora i piani di esecuzione delle query per rilevare i piani di esecuzione che contribuiscono al carico corrente del database e per tenere traccia delle statistiche sulle prestazioni dei piani di esecuzione nel tempo. Per ulteriori informazioni, consulta [Monitoring query execution plans for Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraPostgreSQL.Monitoring.Query.Plans.html). | on |
| authentication\$1timeout | (s) Imposta il tempo massimo concesso per completare l'autenticazione del client. | – |
| auto\$1explain.log\$1analyze | Usa EXPLAIN ANALYZE per la registrazione del piano. | – |
| auto\$1explain.log\$1buffers | Registra l’utilizzo dei buffer. | – |
| auto\$1explain.log\$1format | Formato EXPLAIN da utilizzare per la registrazione del piano. | – |
| auto\$1explain.log\$1min\$1duration | Imposta il tempo minimo di esecuzione al di sopra del quale verranno registrati i piani. | – |
| auto\$1explain.log\$1nested\$1statements | Registra le istruzioni nidificate. | – |
| auto\$1explain.log\$1timing | Raccogli i dati temporali, non solo il numero di righe. | – |
| auto\$1explain.log\$1triggers | Includi statistiche di attivazione nei piani. | – |
| auto\$1explain.log\$1verbose | Usa EXPLAIN VERBOSE per la registrazione del piano. | – |
| auto\$1explain.sample\$1rate | Frazione di query da elaborare. | – |
| autovacuum | Avvia il sottoprocesso autovacuum. | – |
| autovacuum\$1analyze\$1scale\$1factor | Numero di inserimenti, aggiornamenti o eliminazioni di tupla prima dell'analisi come una frazione di reltuple. | 0,05 |
| autovacuum\$1analyze\$1threshold | Numero minimo di inserti, aggiornamenti o eliminazioni di tupla prima dell'analisi. | – |
| autovacuum\$1freeze\$1max\$1age | Età nella quale eseguire l'autovacuum in una tabella per impedire il wraparound ID della transazione. | – |
| autovacuum\$1max\$1workers | Imposta il numero massimo di processi dipendenti di autovacuum in esecuzione simultanea | MASSIMO (DBInstanceClassMemory/64371566592 ,3) |
| autovacuum\$1multixact\$1freeze\$1max\$1age | Età Multixact a cui eseguire l'autovacuum in una tabella per impedire il wraparound multixact. | – |
| autovacuum\$1naptime | (s) Periodo di inattività tra le esecuzioni di autovacuum. | 5 |
| autovacuum\$1vacuum\$1cost\$1delay | (ms) Ritardo del costo del vacuum, in millisecondi, per l'autovacuum. | 5 |
| autovacuum\$1vacuum\$1cost\$1limit | Quantità del costo del vacuum disponibile prima del napping, per l'autovacuum. | MASSIMO (log (/21474836480) \$1600,200) DBInstance ClassMemory |
| autovacuum\$1vacuum\$1insert\$1scale\$1factor | Numero di inserti, aggiornamenti o eliminazioni di tupla prima di eseguire il vacuum come una frazione di reltuple. | – |
| autovacuum\$1vacuum\$1insert\$1threshold | Numero minimo di inserimenti tupla prima del vacuum o -1 per disabilitare i vacuum. | – |
| autovacuum\$1vacuum\$1scale\$1factor | Numero di aggiornamenti o eliminazioni di tupla prima del vacuum come una frazione di reltuple. | 0.1 |
| autovacuum\$1vacuum\$1threshold | Numero minimo di aggiornamenti o eliminazioni di tupla prima del vacuum. | – |
| autovacuum\$1work\$1mem | (kB) Imposta la memoria massima da utilizzare per ogni processo di dipendente autovacuum. | MASSIMO DBInstance ClassMemory (/32768 ,131072) |
| babelfishpg\$1tds.default\$1server\$1name | Il nome del server Babelfish predefinito | Microsoft SQL Server |
| babelfishpg\$1tds.listen\$1address | Imposta il nome host o l'indirizzo o gli indirizzi IP su cui ascoltare TDS. | \$1 |
| babelfishpg\$1tds.port | Imposta la porta TDS TCP su cui il server è in ascolto. | 1433 |
| babelfishpg\$1tds.tds\$1debug\$1log\$1level | Imposta il livello di registrazione in TDS, 0 disabilita la registrazione | 1 |
| babelfishpg\$1tds.tds\$1default\$1numeric\$1precision | Imposta la precisione predefinita del tipo numerico da inviare nei metadati della colonna TDS se il motore non ne specifica uno. | 38 |
| babelfishpg\$1tds.tds\$1default\$1numeric\$1scale | Imposta la scala predefinita di tipo numerico da inviare nei metadati della colonna TDS se il motore non ne specifica uno. | 8 |
| babelfishpg\$1tds.tds\$1default\$1packet\$1size | Imposta la dimensione predefinita del pacchetto per tutti i client SQL Server in fase di connessione | 4096 |
| babelfishpg\$1tds.tds\$1default\$1protocol\$1version | Imposta una versione del protocollo TDS predefinita per tutti i client in fase di connessione | DEFAULT |
| babelfishpg\$1tds.tds\$1ssl\$1encrypt | Imposta l'opzione di crittografia SSL | 0 |
| babelfishpg\$1tds.tds\$1ssl\$1max\$1protocol\$1version | Imposta la versione massima del SSL/TLS protocollo da utilizzare per la sessione tds. | TLSv12. |
| babelfishpg\$1tds.tds\$1ssl\$1min\$1protocol\$1version | Imposta la versione minima SSL/TLS del protocollo da utilizzare per la sessione tds. | TLSv1.2 da Aurora PostgreSQL versione 16, TLSv1 per versioni precedenti a Aurora PostgreSQL versione 16 |
| babelfishpg\$1tsql.default\$1locale | Localizzazione predefinita da utilizzare per le regole di confronto create tramite CREATE COLLATION. | it-IT |
| babelfishpg\$1tsql.migration\$1mode | Definisce se sono supportati più database utente | multi-db da Aurora PostgreSQL versione 16, single-db per versioni precedenti ad Aurora PostgreSQL versione 16 |
| babelfishpg\$1tsql.server\$1collation\$1name | Nome delle regole di confronto del server predefinite | SQL\$1Latin1\$1General\$1CP1\$1CI\$1AS (default) |
| babelfishpg\$1tsql.versione | Imposta l'output della variabile @ @VERSION | default |
| backend\$1flush\$1after | (8Kb) Numero di pagine dopo le quali le scritture eseguite in precedenza vengono riportate su disco. | – |
| backslash\$1quote | Imposta se una doppia barra rovesciata \$1\$1 è consentita nelle stringhe letterali. | – |
| backtrace\$1functions | Registra backtrace per errori in queste funzioni. | – |
| bytea\$1output | Imposta il formato di output per byte. | – |
| check\$1function\$1bodies | Controlla i corpi delle funzioni durante CREATE FUNCTION. | – |
| client\$1connection\$1check\$1interval | Imposta l'intervallo di tempo tra i controlli di disconnessione durante l'esecuzione di query. | – |
| client\$1encoding | Imposta la codifica del set di caratteri del client. | UTF8 |
| client\$1min\$1messages | Imposta i livelli dei messaggi che vengono inviati al client. | – |
| compute\$1query\$1id | Calcola gli identificatori delle query. | auto |
| config\$1file | Imposta il file di configurazione principale del server. | /rdsdbdata/config/postgresql.conf |
| constraint\$1exclusion | Consente al pianificatore di utilizzare i vincoli per ottimizzare le query. | – |
| cpu\$1index\$1tuple\$1cost | Imposta la stima del pianificatore del costo di elaborazione di ciascuna voce di indice durante una scansione dell’indice. | – |
| cpu\$1operator\$1cost | Imposta la stima del pianificatore del costo di elaborazione di ciascuna chiamata dell’operatore o della funzione. | – |
| cpu\$1tuple\$1cost | Imposta la stima del pianificatore del costo di elaborazione di ciascuna tupla (riga). | – |
| cron.database\$1name | Imposta il database per archiviare le tabelle di metadati pg\$1cron | postgres |
| cron.log\$1run | Registra tutti i processi eseguiti nella tabella job\$1run\$1details | on |
| cron.log\$1statement | Registra tutte le istruzioni cron prima dell’esecuzione. | off |
| cron.max\$1running\$1jobs | Numero massimo di processi che possono essere eseguiti contemporaneamente. | 5 |
| cron.use\$1background\$1workers | Abilita i dipendente in background per pg\$1cron | on |
| cursor\$1tuple\$1fraction | Imposta la stima del pianificatore della frazione delle righe del cursore che verranno recuperate. | – |
| data\$1directory | Imposta la directory dei dati dei server. | /rdsdbdata/db |
| datestyle | Imposta il formato del display per i valori di data e ora. | – |
| db\$1user\$1namespace | Abilita i nomi utente per database. | – |
| deadlock\$1timeout | (ms) Imposta il tempo di attesa su un lock prima di verificare il deadlock. | – |
| debug\$1pretty\$1print | I trattini analizzano e visualizzano le visualizzazioni dell’albero. | – |
| debug\$1print\$1parse | Registra ogni albero di analisi della query. | – |
| debug\$1print\$1plan | Registra ogni programma di esecuzione della query. | – |
| debug\$1print\$1rewritten | Registra ogni albero di analisi riscritto della query. | – |
| default\$1statistics\$1target | Imposta la destinazione della statistica predefinita. | – |
| default\$1tablespace | Imposta il tablespace predefinito per la creazione di tabelle e indici. | – |
| default\$1toast\$1compression | Imposta il metodo di compressione predefinito per i valori comprimibili. | – |
| default\$1transaction\$1deferrable | Imposta lo stato differibile predefinito delle nuove transazioni. | – |
| default\$1transaction\$1isolation | Imposta il livello di isolamento della transazione di ogni nuova transazione. | – |
| default\$1transaction\$1read\$1only | Imposta lo stato di sola lettura predefinito delle nuove transazioni. | – |
| effective\$1cache\$1size | (8 kB) Imposta l'ipotesi del pianificatore sulla dimensione della cache del disco. | SOMMA (DBInstanceClassMemory/12038, -50003) |
| effective\$1io\$1concurrency | Numero di richieste simultanee che possono essere gestite in modo efficace dal sottosistema del disco. | – |
| enable\$1async\$1append | Consente ai pianificatori di utilizzare piani di aggiunta asincroni. | – |
| enable\$1bitmapscan | Abilita l’utilizzo da parte del pianificatore di piani di scansione bitmap. | – |
| enable\$1gathermerge | Abilita l’utilizzo da parte del pianificatore di piani di unione di raccolta. | – |
| enable\$1hashagg | Abilita l’utilizzo da parte del pianificatore di piani di aggregazione hash. | – |
| enable\$1hashjoin | Abilita l’utilizzo da parte del pianificatore di piani di unione hash. | – |
| enable\$1incremental\$1sort | Consente ai pianificatori di utilizzare fasi incrementali di ordinamento. | – |
| enable\$1indexonlyscan | Consente ai pianificatori di utilizzare i piani. index-only-scan | – |
| enable\$1indexscan | Abilita l’utilizzo da parte del pianificatore di piani di scansione dell’indice. | – |
| enable\$1material | Abilita l’utilizzo da parte del pianificatore della materializzazione. | – |
| enable\$1memoize | Abilita l'uso della memorizzazione da parte dei pianificatori | – |
| enable\$1mergejoin | Abilita l’utilizzo da parte del pianificatore di piani di unione. | – |
| enable\$1nestloop | Abilita l’utilizzo da parte del pianificatore di piani di unione a ciclo nested. | – |
| enable\$1parallel\$1append | Consente ai pianificatori di utilizzare piani di aggiunta paralleli. | – |
| enable\$1parallel\$1hash | Consente ai pianificatori di utilizzare piani di hash paralleli. | – |
| enable\$1partition\$1pruning | Abilita l’eliminazione delle partizioni del tempo di pianificazione e del runtime. | – |
| enable\$1partitionwise\$1aggregate | Consente l’aggregazione e il raggruppamento a livello di partizione. | – |
| enable\$1partitionwise\$1join | Attiva il join a livello di partizione. | – |
| enable\$1seqscan | Abilita l’utilizzo da parte del pianificatore di piani di scansione sequenziali. | – |
| enable\$1sort | Abilita l’utilizzo da parte del pianificatore di passaggi di ordinamento espliciti. | – |
| enable\$1tidscan | Abilita l’utilizzo da parte del pianificatore di piani di scansione TID. | – |
| escape\$1string\$1warning | Avvisa circa la perdita di barre rovesciate nelle stringhe letterali ordinarie. | – |
| exit\$1on\$1error | Termina la sessione in caso di errore. | – |
| extra\$1float\$1digits | Imposta il numero di cifre visualizzate per i valori del punto variabile. | – |
| force\$1parallel\$1mode | Forza l’uso di strutture di query parallele. | – |
| from\$1collapse\$1limit | Imposta la dimensione dell’elenco FROM oltre la quale le sottoquery non vengono compresse. | – |
| geqo | Abilita l’ottimizzazione genetica delle query. | – |
| geqo\$1effort | GEQO: lo sforzo viene utilizzato per impostare il valore predefinito per altri parametri GEQO. | – |
| geqo\$1generations | GEQO: numero di iterazioni dell’algoritmo. | – |
| geqo\$1pool\$1size | GEQO: numero di individui nella popolazione. | – |
| geqo\$1seed | GEQO: seme per la selezione casuale del percorso. | – |
| geqo\$1selection\$1bias | GEQO: pressione selettiva all’interno della popolazione. | – |
| geqo\$1threshold | Imposta la soglia degli elementi FROM oltre i quali viene utilizzato GEQO. | – |
| gin\$1fuzzy\$1search\$1limit | Imposta il risultato massimo consentito per la ricerca esatta da GIN. | – |
| gin\$1pending\$1list\$1limit | (kB) Imposta la dimensione massima dell'elenco in sospeso per l'indice GIN. | – |
| hash\$1mem\$1multiplier | Multipli di work\$1mem da utilizzare per le tabelle hash. | – |
| hba\$1file | Imposta il file di configurazione hba dei server. | /rdsdbdata/config/pg\$1hba.conf |
| hot\$1standby\$1feedback | Consente il feedback da uno standby a caldo all’elemento primario che eviterà conflitti di query. | on |
| huge\$1pages | Riduce il sovraccarico quando un'istanza database lavora con grandi blocchi di memoria contigui, come quelli utilizzati dai buffer condivisi. È attivato per impostazione predefinita per tutte le classi di istanza database diverse dalle classi di istanza t3.medium, db.t3.large, db.t4g.medium, db.t4g.large | on |
| ident\$1file | Imposta il file di configurazione ident dei server. | /rdsdbdata/config/pg\$1ident.conf |
| idle\$1in\$1transaction\$1session\$1timeout | (ms) Imposta la durata massima concessa di ogni transazione inattiva. | 86400000 |
| idle\$1session\$1timeout | Termina qualsiasi sessione che è rimasta inattiva (ovvero in attesa di una query del client) per un periodo di tempo specificato, ma che non è all'interno di una transazione aperta | – |
| intervalstyle | Imposta il formato del display per i valori dell'intervallo. | – |
| join\$1collapse\$1limit | Imposta la dimensione dell’elenco FROM oltre la quale i costrutti JOIN non vengono appiattiti. | – |
| krb\$1caseins\$1users | Indica se i nomi utente GSSAPI (Generic Security Service API) devono essere trattati senza distinzione tra maiuscole e minuscole (true) o meno. Per impostazione predefinita, questo parametro è impostato su false, quindi Kerberos suppone che i nomi utente applichino la distinzione tra maiuscole e minuscole. Per ulteriori informazioni, consulta la pagina [GSSAPI Authentication](https://www.postgresql.org/docs/current/gssapi-auth.html) (Autenticazione GSSAPI) nella documentazione di PostgreSQL. | false |
| lc\$1messages | Imposta la lingua nella quale vengono visualizzati i messaggi. | – |
| lc\$1monetary | Imposta l'ambientazione per la formattazione degli importi monetari. | – |
| lc\$1numeric | Imposta l'ambientazione per la formattazione degli numeri. | – |
| lc\$1time | Imposta l'ambientazione per la formattazione dei valori di data e ora. | – |
| listen\$1addresses | Imposta il nome host o l'indirizzo o gli indirizzi IP da ascoltare. | \$1 |
| lo\$1compat\$1privileges | Abilita la modalità di compatibilità con le versioni precedenti per i controlli dei privilegi su oggetti di grandi dimensioni. | 0 |
| log\$1autovacuum\$1min\$1duration | (ms) Imposta il tempo minimo di esecuzione al di sopra del quale verranno registrate le azioni di autovacuum. | 10000 |
| log\$1connections | Registra ogni connessione riuscita. | – |
| log\$1destination | Imposta la destinazione per l’output del registro del server. | stderr |
| log\$1directory | Imposta la directory di destinazione per i file di file di log. | /rdsdbdata/log/error |
| log\$1disconnections | Registra la fine di una sessione, compresa la durata. | – |
| log\$1duration | Registra la durata di ogni istruzione SQL completata. | – |
| log\$1error\$1verbosity | Imposta la verbosità dei messaggi registrati. | – |
| log\$1executor\$1stats | Scrive le statistiche sulla prestazione degli esecutori nel registro del server. | – |
| log\$1file\$1mode | Imposta le autorizzazioni del file per i file di file di log. | 0644 |
| log\$1filename | Imposta il modello del nome del file per i file di log. | postgresql.log.%Y-%m-%d-%H%M |
| logging\$1collector | Avvia un sottoprocesso per acquisire i csvlog di output and/or di stderr in file di registro. | 1 |
| log\$1hostname | Registra il nome host nei registri delle connessioni. | 0 |
| logical\$1decoding\$1work\$1mem | (kB) Questa quantità di memoria può essere utilizzata da ogni buffer interno di riordino prima del versamento su disco. | – |
| log\$1line\$1prefix | Controlla le informazioni con prefisso su ciascuna riga di registro. | %t:%r:%u@%d:%p]: |
| log\$1lock\$1waits | Registra lunghe attese di lock. | – |
| log\$1duration\$1sample | (ms) Imposta il tempo minimo di esecuzione al di sopra del quale verrà registrato un campione di istruzioni. Il campionamento è determinato da log\$1statement\$1sample\$1rate. | – |
| log\$1min\$1duration\$1statement | (ms) Imposta il tempo minimo di esecuzione al di sopra del quale verranno registrate le istruzioni. | – |
| log\$1min\$1error\$1statement | Fa sì che tutte le istruzioni che generano un errore pari o superiore a questo livello vengano registrate. | – |
| log\$1min\$1messages | Imposta i livelli dei messaggi che vengono registrati. | – |
| log\$1parameter\$1max\$1length | (B) Quando si registrano le istruzioni, limita i valori dei parametri registrati ai primi N byte. | – |
| log\$1parameter\$1max\$1length\$1on\$1error | (B) Quando si segnala un errore, limita i valori dei parametri registrati ai primi N byte. | – |
| log\$1parser\$1stats | Scrive le statistiche sulla prestazione del decodificatore nel registro del server. | – |
| log\$1planner\$1stats | Scrive le statistiche sulla prestazione del programmatore nel registro del server. | – |
| log\$1replication\$1commands | Registra ogni comando di replica. | – |
| log\$1rotation\$1age | (min) La rotazione del file di log automatico avverrà dopo N minuti. | 60 |
| log\$1rotation\$1size | (kB) La rotazione del file di log automatico avverrà dopo N kilobyte. | 100000 |
| log\$1statement | Imposta il tipo di istruzioni registrate. | – |
| log\$1statement\$1sample\$1rate | Frazione di istruzioni che superano log\$1min\$1duration\$1sample da registrare. | – |
| log\$1statement\$1stats | Scrive le statistiche cumulative sulla prestazione nel registro del server. | – |
| log\$1temp\$1files | (kB) Registra l'uso di file temporanei più grandi di questo numero di kilobyte. | – |
| log\$1timezone | Imposta il fuso orario da utilizzare nei messaggi di registro. | UTC |
| log\$1transaction\$1sample\$1rate | Imposta la frazione di transazioni da registrare per le nuove transazioni. | – |
| log\$1truncate\$1on\$1rotation | Tronca i file di log esistenti con lo stesso nome durante la rotazione del registro. | 0 |
| maintenance\$1io\$1concurrency | Una variante di effective\$1io\$1concurrency utilizzata per i lavori di manutenzione. | 1 |
| maintenance\$1work\$1mem | (kB) Imposta la memoria massima da utilizzare per le operazioni di manutenzione. | MASSIMO DBInstance ClassMemory (/63963136 \$11024,65536) |
| max\$1connections | Imposta il numero massimo di connessioni simultanee. | MINIMO (DBInstanceClassMemory/9531392 5.000) |
| max\$1files\$1per\$1process | Imposta il numero massimo di file aperti in modo simultaneo per ogni processo del server. | – |
| max\$1locks\$1per\$1transaction | Imposta il numero massimo di lock per transazione. | 64 |
| max\$1logical\$1replication\$1workers | Numero massimo di processi di dipendente di replica logica. | – |
| max\$1parallel\$1maintenance\$1workers | Imposta il numero massimo di processi paralleli per operazione di manutenzione. | – |
| max\$1parallel\$1workers | Imposta il numero massimo di worker paralleli che possono essere attivi in una sola volta. | MASSIMO (\$1 VCPU/2,8) DBInstance |
| max\$1parallel\$1workers\$1per\$1gather | Imposta il numero massimo di processi paralleli per nodo executor. | – |
| max\$1pred\$1locks\$1per\$1page | Imposta il numero massimo di tuple bloccate dal predicato per pagina. | – |
| max\$1pred\$1locks\$1per\$1relation | Imposta il numero massimo di pagine e tuple bloccate dal predicato per relazione. | – |
| max\$1pred\$1locks\$1per\$1transaction | Imposta il numero massimo di lock del predicato per transazione. | – |
| max\$1prepared\$1transactions | Imposta il numero massimo di transazioni preparati in modo simultaneo. | 0 |
| max\$1replication\$1slots | Imposta il numero massimo di slot di replica che il server può supportare. | 20 |
| max\$1slot\$1wal\$1keep\$1size | (MB) Gli slot di replica saranno contrassegnati come non riusciti e i segmenti rilasciati per l'eliminazione o il riciclaggio se questo spazio è occupato dai WAL su disco. | – |
| max\$1stack\$1depth | (kB) Imposta la profondità massima della pila in kilobyte. | 6144 |
| max\$1standby\$1streaming\$1delay | (ms) Imposta il ritardo massimo prima di annullare le query quando un server con standby a caldo elabora i dati WAL in streaming. | 14000 |
| max\$1sync\$1workers\$1per\$1subscription | Numero massimo di worker di sincronizzazione per abbonamento | 2 |
| max\$1wal\$1senders | Imposta il numero massimo di processi del mittente WAL in esecuzione simultanea | 10 |
| max\$1worker\$1processes | Imposta il numero massimo di processi dipendente simultanei. | MASSIMO (\$1 VCPU\$12,8) DBInstance |
| min\$1dynamic\$1shared\$1memory | (MB) Quantità di memoria condivisa dinamica riservata all'avvio. | – |
| min\$1parallel\$1index\$1scan\$1size | (8 kB) Imposta la quantità minima di dati di indicizzazione per una scansione parallela. | – |
| min\$1parallel\$1table\$1scan\$1size | (8 kB) Imposta la quantità minima di dati della tabella per una scansione parallela. | – |
| old\$1snapshot\$1threshold | (min) Tempo prima che uno snapshot sia troppo vecchio per leggere le pagine modificate dopo l'acquisizione dello snapshot. | – |
| orafce.nls\$1date\$1format | Emula il comportamento di output oracles date. | – |
| orafce.timezone | Specifica il fuso orario utilizzato per la funzione sysdate. | – |
| parallel\$1leader\$1participation | Controlla se Gather e Gather Merge eseguono anche piani secondari. | – |
| parallel\$1setup\$1cost | Imposta la stima dei pianificatori del costo di avvio dei processi dei dipendenti per la query parallela. | – |
| parallel\$1tuple\$1cost | Imposta la stima del pianificatore del costo del passaggio di ciascuna tupla (riga) dal back-end dipendente a quello principale. | – |
| password\$1encryption | Crittografa le password. | – |
| pgaudit.log | Specifica quali classi di istruzioni verranno registrate per registrazione di verifica della sessione. | – |
| pgaudit.log\$1catalog | Specifica che la registrazione delle sessioni deve essere abilitata nel caso in cui tutte le relazioni in un’istruzione siano in pg\$1catalog. | – |
| pgaudit.log\$1level | Specifica il livello di log che verrà utilizzato per le voci di registro. | – |
| pgaudit.log\$1parameter | Specifica che la registrazione di log di audit deve includere i parametri passati con l’istruzione. | – |
| pgaudit.log\$1relation | Specifica se la registrazione di verifica della sessione deve creare una voce di registro separata per ogni relazione (TABLE, VIEW, ecc.) a cui fa riferimento in un'istruzione SELECT o DML. | – |
| pgaudit.log\$1statement\$1once | Speciifica se la registrazione includerà il testo e i parametri dell'istruzione con la prima voce di registro per una combinazione o con ogni voce. statement/substatement | – |
| pgaudit.role | Specifica il ruolo principale da utilizzare per la registrazione di verifica degli oggetti. | – |
| pg\$1bigm.enable\$1recheck | Specifica se eseguire Recheck, che è un processo interno di ricerca full-text. | on |
| pg\$1bigm.gin\$1key\$1limit | Specifica il numero massimo di 2-grammi della parola chiave di ricerca da utilizzare per la ricerca full-text. | 0 |
| pg\$1bigm.last\$1update | Riporta l’ultima data aggiornata del modulo pg\$1bigm. | 2013.11.22 |
| pg\$1bigm.similarity\$1limit | Specifica la soglia minima utilizzata dalla ricerca di somiglianza. | 0.3 |
| pg\$1hint\$1plan.debug\$1print | Registra i risultati dell’analisi dei suggerimenti. | – |
| pg\$1hint\$1plan.enable\$1hint | Forza il pianificatore a utilizzare i piani specificati nel commento del suggerimento precedente alla query. | – |
| pg\$1hint\$1plan.enable\$1hint\$1table | Forza il pianificatore a non ottenere indicazioni utilizzando le ricerche nella tabella. | – |
| pg\$1hint\$1plan.message\$1level | Livello di messaggio dei messaggi di debug. | – |
| pg\$1hint\$1plan.parse\$1messages | Livello di messaggio degli errori di analisi. | – |
| pglogical.batch\$1inserts | Inserimenti batch, se possibile | – |
| pglogical.conflict\$1log\$1level | Imposta il livello di registro utilizzato per la registrazione dei conflitti risolti. | – |
| pglogical.conflict\$1resolution | Imposta il metodo utilizzato per la risoluzione dei conflitti per i conflitti risolvibili. | – |
| pglogical.extra\$1connection\$1options | opzioni di connessione da aggiungere a tutte le connessioni dei nodi peer | – |
| pglogical.synchronous\$1commit | Valore di commit sincrono specifico pglogical | – |
| pglogical.use\$1spi | Usa SPI invece dell’API di basso livello per applicare le modifiche | – |
| pgtle.clientauth\$1databases\$1to\$1skip | Elenco di database da saltare per la funzionalità clientauth. | – |
| pgtle.clientauth\$1db\$1name | Controlla quale database viene utilizzato per la funzionalità clientauth. | – |
| pgtle.clientauth\$1num\$1parallel\$1workers | Numero di worker in background utilizzati per la funzionalità clientauth. | – |
| pgtle.clientauth\$1users\$1to\$1skip | Elenco di utenti da saltare per la funzionalità clientauth. | – |
| pgtle.enable\$1clientauth | Abilita la funzionalità clientauth. | – |
| pgtle.passcheck\$1db\$1name | Imposta quale database viene utilizzato per la funzionalità passcheck a livello di cluster. | – |
| pg\$1prewarm.autoprewarm | Avvia il dipendente di pre-riscaldamento automatico. | – |
| pg\$1prewarm.autoprewarm\$1interval | Imposta l'intervallo tra i dump dei buffer condivisi | – |
| pg\$1similarity.block\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarity.block\$1threshold | Imposta la soglia utilizzata dalla funzione di similarità dei blocchi. | – |
| pg\$1similarity.block\$1tokenizer | Imposta il tokenizzatore per la funzione di similarità dei blocchi. | – |
| pg\$1similarity.cosine\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarity.cosine\$1threshold | Imposta la soglia utilizzata dalla funzione di similarità del coseno. | – |
| pg\$1similarity.cosine\$1tokenizer | Imposta il tokenizzatore per la funzione di similarità del coseno. | – |
| pg\$1similarity.dice\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarity.dice\$1threshold | Imposta la soglia utilizzata dalla misura di similarità di Dice. | – |
| pg\$1similarity.dice\$1tokenizer | Imposta il tokenizzatore per la misura di similarità di Dice. | – |
| pg\$1similarity.euclidean\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarity.euclidean\$1threshold | Imposta la soglia utilizzata dalla misura di similarità euclidea. | – |
| pg\$1similarity.euclidean\$1tokenizer | Imposta il tokenizzatore per la misura di similarità euclidea. | – |
| pg\$1similarity.hamming\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarity.hamming\$1threshold | Imposta la soglia utilizzata dal parametro di similarità dei blocchi. | – |
| pg\$1similarity.jaccard\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarity.jaccard\$1threshold | Imposta la soglia utilizzata dalla misura di similarità di Jaccard. | – |
| pg\$1similarity.jaccard\$1tokenizer | Imposta il tokenizzatore per la misura di similarità di Jaccard. | – |
| pg\$1similarity.jaro\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarity.jaro\$1threshold | Imposta la soglia utilizzata dalla misura di similarità di Jaro. | – |
| pg\$1similarity.jarowinkler\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarity.jarowinkler\$1threshold | Imposta la soglia utilizzata dalla misura di similarità di Jarowinkler. | – |
| pg\$1similarity.levenshtein\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarity.levenshtein\$1threshold | Imposta la soglia utilizzata dalla misura di similarità di Levenshtein. | – |
| pg\$1similarity.matching\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarity.matching\$1threshold | Imposta la soglia utilizzata dalla misura di similarità del coefficiente di corrispondenza. | – |
| pg\$1similarity.matching\$1tokenizer | Imposta il tokenizzatore per la misura di similarità del coefficiente di corrispondenza. | – |
| pg\$1similarity.mongeelkan\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarity.mongeelkan\$1threshold | Imposta la soglia utilizzata dalla misura di similarità di Monge-Elkan. | – |
| pg\$1similarity.mongeelkan\$1tokenizer | Imposta il tokenizzatore per la misura di similarità di Monge-Elkan. | – |
| pg\$1similarity.nw\$1gap\$1penalty | Imposta la penalità del gap utilizzata dalla misura di similitudine di Needleman-Wunsch. | – |
| pg\$1similarity.nw\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarity.nw\$1threshold | Imposta la soglia utilizzata dalla misura di similitudine di Needleman-Wunsch. | – |
| pg\$1similarity.overlap\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarity.overlap\$1threshold | Imposta la soglia utilizzata dalla misura di similarità del coefficiente di sovrapposizione. | – |
| pg\$1similarity.overlap\$1tokenizer | Imposta il tokenizzatore per la misura di similarità del coefficiente di sovrapposizione. | – |
| pg\$1similarity.qgram\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarity.qgram\$1threshold | Imposta la soglia utilizzata dalla misura di similitudine Q-Gram. | – |
| pg\$1similarity.qgram\$1tokenizer | Imposta il tokenizzatore per la misura Q-Gram. | – |
| pg\$1similarity.swg\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarità.swg\$1threshold | Imposta la soglia utilizzata dalla misura di somiglianza Smith-Waterman-Gotoh. | – |
| pg\$1similarity.sw\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarity.sw\$1threshold | Imposta la soglia utilizzata dalla misura di similitudine di Smith-Waterman. | – |
| pg\$1stat\$1statements.max | Imposta il numero massimo di istruzioni monitorate da pg\$1stat\$1statements. | – |
| pg\$1stat\$1statements.save | Salva le statistiche pg\$1stat\$1statements attraverso le interruzioni del server. | – |
| pg\$1stat\$1statements.track | Seleziona le istruzioni che vengono monitorate da pg\$1stat\$1statements. | – |
| pg\$1stat\$1statements.track\$1planning | Seleziona se la durata della pianificazione è monitorata da pg\$1stat\$1statements. | – |
| pg\$1stat\$1statements.track\$1utility | Seleziona se i comandi di utilità sono monitorati da pg\$1stat\$1statements. | – |
| plan\$1cache\$1mode | Controlla la selezione da parte del pianificatore di un piano personalizzato o generico. | – |
| port | Imposta la porta TCP su cui il server è in ascolto. | EndPointPort |
| postgis.gdal\$1enabled\$1drivers | Abilita o disabilita i driver GDAL utilizzati con PostGIS in Postgres 9.3.5 e versioni successive. | ENABLE\$1ALL |
| quote\$1all\$1identifiers | Aggiungi le virgolette a tutti gli identificatori quando si generano i frammenti SQL. | – |
| random\$1page\$1cost | Imposta la stima del pianificatore del costo di una pagina del disco recuperata in modo non sequenziale. | – |
| rdkit.dice\$1threshold | Soglia inferiore di somiglianza Dice. Le molecole con somiglianza inferiore alla soglia non sono simili per operazione \$1. | – |
| rdkit.do\$1chiral\$1sss | È bene prendere in considerazione la stereochimica nella corrispondenza delle sottostrutture. Se false, non vengono utilizzate informazioni stereochimiche nelle corrispondenze della sottostruttura. | – |
| rdkit.tanimoto\$1threshold | Soglia inferiore di somiglianza Tanimoto. Le molecole con somiglianza inferiore alla soglia non sono simili per operazione %. | – |
| rds.accepted\$1password\$1auth\$1method | Forza l'autenticazione per le connessioni con password archiviata localmente. | md5\$1scram |
| rds.adaptive\$1autovacuum | Parametro RDS per l'autovacuum enable/disable adattivo. | 1 |
| rds.babelfish\$1status | Parametro RDS per enable/disable Babelfish per Aurora PostgreSQL. | off |
| rds.enable\$1plan\$1management | Abilita o disabilita l'estensione apg\$1plan\$1mgmt. | 0 |
| rds.extensions | Elenco di estensioni fornite da RDS | address\$1standardizer, address\$1standardizer\$1data\$1us, apg\$1plan\$1mgmt, aurora\$1stat\$1utils, amcheck, autoinc, aws\$1commons, aws\$1ml, aws\$1s3, aws\$1lambda, bool\$1plperl, bloom, btree\$1gin, btree\$1gist, citext, cube, dblink, dict\$1int, dict\$1xsyn, earthdistance, fuzzystrmatch, hll, hstore, hstore\$1plperl, insert\$1username, intagg, intarray, ip4r, isn, jsonb\$1plperl, lo, log\$1fdw, ltree, moddatetime, old\$1snapshot, oracle\$1fdw, orafce, pgaudit, pgcrypto, pglogical, pgrouting, pgrowlocks, pgstattuple, pgtap, pg\$1bigm, pg\$1buffercache, pg\$1cron, pg\$1freespacemap, pg\$1hint\$1plan, pg\$1partman, pg\$1prewarm, pg\$1proctab, pg\$1repack, pg\$1similarity, pg\$1stat\$1statements, pg\$1trgm, pg\$1visibility, plcoffee, plls, plperl, plpgsql, plprofiler, pltcl, plv8, postgis, postgis\$1tiger\$1geocoder, postgis\$1raster, postgis\$1topology, postgres\$1fdw, prefix, rdkit, rds\$1tools, refint, sslinfo, tablefunc, tds\$1fdw, test\$1parser, tsm\$1system\$1rows, tsm\$1system\$1time, unaccent, uuid-ossp |
| rds.force\$1admin\$1logging\$1level | Visualizza i messaggi di registro per le azioni dell’utente amministratore di RDS nei database dei clienti. | – |
| rds.force\$1autovacuum\$1logging\$1level | Visualizza i messaggi dei registri relativi alle operazioni di autovacuum. | ATTENZIONE |
| rds.force\$1ssl | Forza le connessioni SSL. | 0 |
| rds.global\$1db\$1rpo | (s) Soglia dell'obiettivo del punto di ripristino, in secondi, che blocca i commit dell'utente quando viene violata. Questo parametro è destinato ai database globali Aurora basati su PostgreSQL. Per un database non globale, lasciare il valore predefinito. Per ulteriori informazioni su questo parametro, consulta [Gestione degli RPO per database globali basati su Aurora PostgreSQL–](aurora-global-database-disaster-recovery.md#aurora-global-database-manage-recovery). | – |
| rds.logical\$1replication | Abilita la decodifica logica. | 0 |
| rds.logically\$1replicate\$1unlogged\$1tables | Le tabelle non registrate vengono replicate logicamente. | 1 |
| rds.log\$1retention\$1period | Amazon RDS elimina i registri PostgreSQL più vecchi di N minuti. | 4320 |
| rds.pg\$1stat\$1ramdisk\$1size | Dimensioni del ramdisk delle statistiche in MB. Un valore diverso da zero configurerà il ramdisk. Questo parametro è disponibile solo in Aurora PostgreSQL 14 e versioni precedenti. | 0 |
| rds.rds\$1superuser\$1reserved\$1connections | Imposta il numero di slot di connessione riservati a rds\$1superusers. Questo parametro è disponibile solo nella versione 15 e precedenti. Per ulteriori informazioni, consulta le [connessioni riservate](https://www.postgresql.org/docs/current/runtime-config-connection.html#GUC-RESERVED-CONNECTIONS) nella documentazione di PostgreSQL. | 2 |
| rds.restrict\$1password\$1commands | limita i comandi relativi alla password ai membri di rds\$1password | – |
| rds.superuser\$1variables | Elenco delle variabili del solo utente con privilegi avanzati per le quali eleviamo le istruzioni di modifica rds\$1superuser. | session\$1replication\$1role |
| recovery\$1init\$1sync\$1method | Imposta il metodo per sincronizzare la directory dei dati prima del ripristino da arresto anomalo. | syncfs |
| remove\$1temp\$1files\$1after\$1crash | Rimuove i file temporanei dopo l'arresto anomalo del back-end | 0 |
| restart\$1after\$1crash | Reinizializza il server dopo l’arresto anomalo del back-end. | – |
| row\$1security | Abilita la sicurezza delle righe. | – |
| search\$1path | Imposta l’ordine di ricerca dello schema per i nomi che non sono qualificati come schema. | – |
| seq\$1page\$1cost | Imposta la stima del pianificatore del costo di una pagina del disco recuperata in modo sequenziale. | – |
| session\$1replication\$1role | Imposta il comportamento delle sessioni per i trigger e le regole di riscrittura. | – |
| shared\$1buffers | (8 kB) Imposta il numero di buffer di memoria condivisa utilizzati dal server. | SOMMA (DBInstanceClassMemory/12038, -50003) |
| shared\$1preload\$1libraries | Elenca le librerie condivise da precaricare nel server. | pg\$1stat\$1statements |
| ssl | Abilita le connessioni SSL. | 1 |
| ssl\$1ca\$1file | Posizione del file dell’autorità del server SSL. | /-cert.pem rdsdbdata/rds-metadata/ca |
| ssl\$1cert\$1file | Posizione del file del certificato del server SSL. | /rdsdbdata/rds-metadata/server-cert.pem |
| ssl\$1ciphers | Imposta l'elenco delle crittografie TLS consentite da utilizzare su connessioni sicure. | – |
| ssl\$1crl\$1dir | Posizione della directory dell'elenco di revoche di certificati SSL. | /rdsdbdata/rds-metadata/ssl\$1crl\$1dir/ |
| ssl\$1key\$1file | Posizione del file della chiave privata del server SSL | /rdsdbdata/rds-metadata/server-chiave.pem |
| ssl\$1max\$1protocol\$1version | Imposta la versione massima del protocollo consentita SSL/TLS | – |
| ssl\$1min\$1protocol\$1version | Imposta la versione minima SSL/TLS del protocollo consentita | TLSv12. |
| standard\$1conforming\$1strings | Fa sì che le stringhe ... trattino letteralmente le barre rovesciate. | – |
| statement\$1timeout | (ms) Imposta la durata massima concessa di ogni istruzione. | – |
| stats\$1temp\$1directory | Scrive i file di statistiche temporanei nella directory specificata. | /rdsdbdata/db/pg\$1stat\$1tmp |
| superuser\$1reserved\$1connections | Imposta il numero di slot di connessione riservati agli utenti con privilegi avanzati. | 3 |
| synchronize\$1seqscans | Abilita le scansioni sequenziali sincronizzate. | – |
| synchronous\$1commit | Imposta il livello di sincronizzazione delle transazioni correnti. | on |
| tcp\$1keepalives\$1count | Numero massimo di ritrasmissioni keepalive TCP. | – |
| tcp\$1keepalives\$1idle | (s) Tempo tra l'emissione di keepalive TCP. | – |
| tcp\$1keepalives\$1interval | (s) Tempo tra la ritrasmissione di keepalive TCP. | – |
| temp\$1buffers | (8 kB) Imposta il numero massimo di buffer temporanei utilizzati da ogni sessione. | – |
| temp\$1file\$1limit | Vincola la quantità totale di spazio su disco in kilobyte che un determinato processo PostgreSQL può utilizzare per i file temporanei, escludendo lo spazio utilizzato per tabelle temporanee esplicite | -1 |
| temp\$1tablespaces | Imposta i tablespace da usare per le tabelle temporanee e i file di ordinamento. | – |
| timezone | Imposta il fuso orario per la visualizzazione e l'interpretazione dei timestamp. | UTC |
| track\$1activities | Raccoglie informazioni sui comandi di esecuzione. | – |
| track\$1activity\$1query\$1size | Imposta la dimensione riservata per pg\$1stat\$1activity.current\$1query, in byte. | 4096 |
| track\$1commit\$1timestamp | Raccoglie l'ora di commit della transazione. | – |
| track\$1counts | Raccoglie statistiche sull’attività del database. | – |
| track\$1functions | Raccoglie statistiche a livello di funzione sull’attività del database. | pl |
| track\$1io\$1timing | Raccoglie statistiche di temporizzazione sull’attività di I/O del database. | 1 |
| track\$1wal\$1io\$1timing | Raccoglie statistiche di temporizzazione per l'attività di I/O WAL. | – |
| transform\$1null\$1equals | Tratta expr=NULL come expr È NULL. | – |
| update\$1process\$1title | Aggiorna il titolo del processo per mostrare il comando SQL attivo. | – |
| vacuum\$1cost\$1delay | (ms) Ritardo del costo del vacuum, in millisecondi. | – |
| vacuum\$1cost\$1limit | Quantità del costo del vacuum disponibile prima del napping. | – |
| vacuum\$1cost\$1page\$1dirty | Costo del vacuum per una pagina sporcata dal vacuum. | – |
| vacuum\$1cost\$1page\$1hit | Costo del vacuum per una pagina trovata nella cache del buffer. | – |
| vacuum\$1cost\$1page\$1miss | Costo del vacuum per una non pagina trovata nella cache del buffer. | 0 |
| vacuum\$1defer\$1cleanup\$1age | Numero di transazioni in base alle quali il VACUUM e la pulizia A CALDO devono essere posticipati, se presenti. | – |
| vacuum\$1failsafe\$1age | Età in cui il VACUUM deve attivare una misura di sicurezza per evitare un'interruzione del wraparound. | 1200000000 |
| vacuum\$1freeze\$1min\$1age | Età minima in cui il VACUUM dovrebbe congelare una riga della tabella. | – |
| vacuum\$1freeze\$1table\$1age | Età in cui il VACUUM dovrebbe eseguire la scansione di un'intera tabella per congelare le tuple. | – |
| vacuum\$1multixact\$1failsafe\$1age | Età multixact in cui il VACUUM deve attivare una misura di sicurezza per evitare un'interruzione del wraparound. | 1200000000 |
| vacuum\$1multixact\$1freeze\$1min\$1age | Età minima alla quale VACUUM deve congelare un file MultiXactId in una riga della tabella. | – |
| vacuum\$1multixact\$1freeze\$1table\$1age | Età del Multixact in cui il VACUUM dovrebbe eseguire la scansione di un'intera tabella per congelare le tuple. | – |
| wal\$1buffer | (8 kB) Imposta il numero di buffer della pagina del disco nella memoria condivisa per WAL. | – |
| wal\$1receiver\$1create\$1temp\$1slot | Imposta se un ricevitore WAL deve creare uno slot di replica temporaneo se non è configurato uno slot permanente. | 0 |
| wal\$1receiver\$1status\$1interval | (s) Imposta l'intervallo massimo tra i report di stato del ricevitore WAL al nodo primario. | – |
| wal\$1receiver\$1timeout | (ms) Imposta il tempo di attesa massimo per la ricezione dei dati dal nodo primario. | 30000 |
| wal\$1sender\$1timeout | (ms) Imposta il tempo massimo di attesa della replica WAL. | – |
| work\$1mem | (kB) Imposta la memoria massima da utilizzare per gli spazi di lavoro delle query. | – |
| xmlbinary | Imposta come i valori binari devono essere codificati in XML. | – |
| xmloption | Imposta se i dati XML nelle operazioni di analisi e serializzazione implicite devono essere considerati come documenti o frammenti di contenuto. | – |
## Parametri a livello di istanza Aurora PostgreSQL
Puoi visualizzare i parametri a livello di istanza disponibili per una versione specifica di Aurora PostgreSQL utilizzando la console di AWS gestione, la CLI o l'API Amazon RDS. AWS Per informazioni sulla visualizzazione dei parametri in un gruppo di parametri del database Aurora PostgreSQL nella console RDS, consultare [Visualizzazione dei valori dei parametri per un gruppo di parametri del database in Amazon Aurora](USER_WorkingWithParamGroups.Viewing.md).
Alcuni parametri a livello di istanza non sono disponibili in tutte le versioni e alcuni sono obsoleti. Per informazioni sulla visualizzazione dei parametri di una versione specifica di Aurora PostgreSQL, consultare [Visualizzazione del cluster di database Aurora PostgreSQL e dei parametri del database](#AuroraPostgreSQL.Reference.ParameterGroups-viewing-parameters).
Ad esempio, nella tabella seguente sono elencati i parametri applicabili a una specifica istanza database di un cluster database Aurora PostgreSQL. Questo elenco è stato generato eseguendo il comando con for the value. [describe-db-parameters](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-parameters.html) AWS CLI `default.aurora-postgresql14``--db-parameter-group-name`
Per un elenco dei parametri del cluster database per lo stesso gruppo di parametri DB, consulta [Parametri a livello di cluster Aurora PostgreSQL](#AuroraPostgreSQL.Reference.Parameters.Cluster).
| Nome del parametro | Description | Predefinita |
| --- | --- | --- |
| apg\$1enable\$1batch\$1mode\$1function\$1execution | Consente alle funzioni in modalità batch di elaborare serie di righe in una volta. | – |
| apg\$1enable\$1correlated\$1any\$1transform | Consente al pianificatore di trasformare il link secondario ANY (sottoquery IN/NOT IN) in JOIN quando possibile. | – |
| apg\$1enable\$1function\$1migration | Consente al pianificatore di migrare le funzioni scalari idonee alla clausola FROM. | – |
| apg\$1enable\$1not\$1in\$1transform | Consente al pianificatore di trasformare la query secondaria NOT IN in ANTI JOIN quando possibile. | – |
| apg\$1enable\$1remove\$1redundant\$1inner\$1joins | Consente al pianificatore di rimuovere i join interni ridondanti. | – |
| apg\$1enable\$1semijoin\$1push\$1down | Consente l’utilizzo di filtri semijoin per gli hash join. | – |
| apg\$1plan\$1mgmt.capture\$1plan\$1baselines | Modalità baseline di acquisizione del piano. manual (manuale): abilita l'acquisizione del piano per qualsiasi istruzione SQL, off: disabilita l'acquisizione del piano, automatic (automatica): abilita l'acquisizione del piano per le istruzioni in pg\$1stat\$1statements che soddisfano i criteri di idoneità. | off |
| apg\$1plan\$1mgmt.max\$1databases | Imposta il numero massimo di database che possono gestire le query utilizzando apg\$1plan\$1mgmt. | 10 |
| apg\$1plan\$1mgmt.max\$1plans | Imposta il numero massimo di piani che possono essere memorizzati nella cache da apg\$1plan\$1mgmt. | 10000 |
| apg\$1plan\$1mgmt.plan\$1retention\$1period | Numero massimo di giorni dall’ultimo utilizzo di un piano prima che venga eliminato automaticamente. | 32 |
| apg\$1plan\$1mgmt.unapproved\$1plan\$1execution\$1threshold | Costo totale stimato del piano al di sotto del quale verrà eseguito un piano non approvato. | 0 |
| apg\$1plan\$1mgmt.use\$1plan\$1baselines | Utilizzare solo piani approvati o fissi per le istruzioni gestite. | false |
| application\$1name | Imposta il nome dell’applicazione da riportare nelle statistiche e nei registri. | – |
| aurora\$1compute\$1plan\$1id | Monitora i piani di esecuzione delle query per rilevare i piani di esecuzione che contribuiscono al carico corrente del database e per tenere traccia delle statistiche sulle prestazioni dei piani di esecuzione nel tempo. Per ulteriori informazioni, consulta [Monitoring query execution plans for Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraPostgreSQL.Monitoring.Query.Plans.html). | on |
| aurora\$1temp\$1space\$1size | (MB) Imposta la dimensione dello spazio allocato per gli oggetti temporanei abilitati alle letture ottimizzate su cluster Aurora ottimizzati per I/O con classi di istanze supportate. | DBInstanceClassMemory/524288 |
| authentication\$1timeout | (s) Imposta il tempo massimo concesso per completare l'autenticazione del client. | – |
| auto\$1explain.log\$1analyze | Usa EXPLAIN ANALYZE per la registrazione del piano. | – |
| auto\$1explain.log\$1buffers | Registra l’utilizzo dei buffer. | – |
| auto\$1explain.log\$1format | Formato EXPLAIN da utilizzare per la registrazione del piano. | – |
| auto\$1explain.log\$1min\$1duration | Imposta il tempo minimo di esecuzione al di sopra del quale verranno registrati i piani. | – |
| auto\$1explain.log\$1nested\$1statements | Registra le istruzioni nidificate. | – |
| auto\$1explain.log\$1timing | Raccogli i dati temporali, non solo il numero di righe. | – |
| auto\$1explain.log\$1triggers | Includi statistiche di attivazione nei piani. | – |
| auto\$1explain.log\$1verbose | Usa EXPLAIN VERBOSE per la registrazione del piano. | – |
| auto\$1explain.sample\$1rate | Frazione di query da elaborare. | – |
| babelfishpg\$1tds.listen\$1address | Imposta il nome host o l'indirizzo/gli indirizzi IP su cui ascoltare TDS. | \$1 |
| babelfishpg\$1tds.tds\$1debug\$1log\$1level | Imposta il livello di registrazione in TDS, 0 disabilita la registrazione | 1 |
| backend\$1flush\$1after | (8Kb Numero di pagine dopo le quali le scritture eseguite in precedenza vengono riportate su disco. | – |
| bytea\$1output | Imposta il formato di output per byte. | – |
| check\$1function\$1bodies | Controlla i corpi delle funzioni durante CREATE FUNCTION. | – |
| client\$1connection\$1check\$1interval | Imposta l'intervallo di tempo tra i controlli di disconnessione durante l'esecuzione di query. | – |
| client\$1min\$1messages | Imposta i livelli dei messaggi che vengono inviati al client. | – |
| config\$1file | Imposta il file di configurazione principale del server. | /.conf rdsdbdata/config/postgresql |
| constraint\$1exclusion | Consente al pianificatore di utilizzare i vincoli per ottimizzare le query. | – |
| cpu\$1index\$1tuple\$1cost | Imposta la stima del pianificatore del costo di elaborazione di ciascuna voce di indice durante una scansione dell’indice. | – |
| cpu\$1operator\$1cost | Imposta la stima del pianificatore del costo di elaborazione di ciascuna chiamata dell’operatore o della funzione. | – |
| cpu\$1tuple\$1cost | Imposta la stima del pianificatore del costo di elaborazione di ciascuna tupla (riga). | – |
| cron.database\$1name | Imposta il database per archiviare le tabelle di metadati pg\$1cron | postgres |
| cron.log\$1run | Registra tutti i processi eseguiti nella tabella job\$1run\$1details | on |
| cron.log\$1statement | Registra tutte le istruzioni cron prima dell’esecuzione. | off |
| cron.max\$1running\$1jobs | Numero massimo di processi che possono essere eseguiti contemporaneamente. | 5 |
| cron.use\$1background\$1workers | Abilita i dipendente in background per pg\$1cron | on |
| cursor\$1tuple\$1fraction | Imposta la stima del pianificatore della frazione delle righe del cursore che verranno recuperate. | – |
| db\$1user\$1namespace | Abilita i nomi utente per database. | – |
| deadlock\$1timeout | (ms) Imposta il tempo di attesa su un lock prima di verificare il deadlock. | – |
| debug\$1pretty\$1print | I trattini analizzano e visualizzano le visualizzazioni dell’albero. | – |
| debug\$1print\$1parse | Registra ogni albero di analisi della query. | – |
| debug\$1print\$1plan | Registra ogni programma di esecuzione della query. | – |
| debug\$1print\$1rewritten | Registra ogni albero di analisi riscritto della query. | – |
| default\$1statistics\$1target | Imposta la destinazione della statistica predefinita. | – |
| default\$1transaction\$1deferrable | Imposta lo stato differibile predefinito delle nuove transazioni. | – |
| default\$1transaction\$1isolation | Imposta il livello di isolamento della transazione di ogni nuova transazione. | – |
| default\$1transaction\$1read\$1only | Imposta lo stato di sola lettura predefinito delle nuove transazioni. | – |
| effective\$1cache\$1size | (8 kB) Imposta l'ipotesi dei pianificatori sulla dimensione della cache del disco. | SOMMA (DBInstanceClassMemory/12038, -50003) |
| effective\$1io\$1concurrency | Numero di richieste simultanee che possono essere gestite in modo efficace dal sottosistema del disco. | – |
| enable\$1async\$1append | Consente ai pianificatori di utilizzare piani di aggiunta asincroni. | – |
| enable\$1bitmapscan | Abilita l’utilizzo da parte del pianificatore di piani di scansione bitmap. | – |
| enable\$1gathermerge | Abilita l’utilizzo da parte del pianificatore di piani di unione di raccolta. | – |
| enable\$1hashagg | Abilita l’utilizzo da parte del pianificatore di piani di aggregazione hash. | – |
| enable\$1hashjoin | Abilita l’utilizzo da parte del pianificatore di piani di unione hash. | – |
| enable\$1incremental\$1sort | Consente ai pianificatori di utilizzare fasi incrementali di ordinamento. | – |
| enable\$1indexonlyscan | Consente ai pianificatori di utilizzare i piani. index-only-scan | – |
| enable\$1indexscan | Abilita l’utilizzo da parte del pianificatore di piani di scansione dell’indice. | – |
| enable\$1material | Abilita l’utilizzo da parte del pianificatore della materializzazione. | – |
| enable\$1memoize | Abilita l'uso della memorizzazione da parte dei pianificatori | – |
| enable\$1mergejoin | Abilita l’utilizzo da parte del pianificatore di piani di unione. | – |
| enable\$1nestloop | Abilita l’utilizzo da parte del pianificatore di piani di unione a ciclo nested. | – |
| enable\$1parallel\$1append | Consente ai pianificatori di utilizzare piani di aggiunta paralleli. | – |
| enable\$1parallel\$1hash | Consente ai pianificatori di utilizzare piani di hash paralleli. | – |
| enable\$1partition\$1pruning | Abilita l’eliminazione delle partizioni del tempo di pianificazione e del runtime. | – |
| enable\$1partitionwise\$1aggregate | Consente l’aggregazione e il raggruppamento a livello di partizione. | – |
| enable\$1partitionwise\$1join | Attiva il join a livello di partizione. | – |
| enable\$1seqscan | Abilita l’utilizzo da parte del pianificatore di piani di scansione sequenziali. | – |
| enable\$1sort | Abilita l’utilizzo da parte del pianificatore di passaggi di ordinamento espliciti. | – |
| enable\$1tidscan | Abilita l’utilizzo da parte del pianificatore di piani di scansione TID. | – |
| escape\$1string\$1warning | Avvisa circa la perdita di barre rovesciate nelle stringhe letterali ordinarie. | – |
| exit\$1on\$1error | Termina la sessione in caso di errore. | – |
| force\$1parallel\$1mode | Forza l’uso di strutture di query parallele. | – |
| from\$1collapse\$1limit | Imposta la dimensione dell’elenco FROM oltre la quale le sottoquery non vengono compresse. | – |
| geqo | Abilita l’ottimizzazione genetica delle query. | – |
| geqo\$1effort | GEQO: lo sforzo viene utilizzato per impostare il valore predefinito per altri parametri GEQO. | – |
| geqo\$1generations | GEQO: numero di iterazioni dell’algoritmo. | – |
| geqo\$1pool\$1size | GEQO: numero di individui nella popolazione. | – |
| geqo\$1seed | GEQO: seme per la selezione casuale del percorso. | – |
| geqo\$1selection\$1bias | GEQO: pressione selettiva all’interno della popolazione. | – |
| geqo\$1threshold | Imposta la soglia degli elementi FROM oltre i quali viene utilizzato GEQO. | – |
| gin\$1fuzzy\$1search\$1limit | Imposta il risultato massimo consentito per la ricerca esatta da GIN. | – |
| gin\$1pending\$1list\$1limit | (kB) Imposta la dimensione massima dell'elenco in sospeso per l'indice GIN. | – |
| hash\$1mem\$1multiplier | Multipli di work\$1mem da utilizzare per le tabelle hash. | – |
| hba\$1file | Imposta il file di configurazione hba dei server. | /rdsdbdata/config/pg\$1hba.conf |
| hot\$1standby\$1feedback | Consente il feedback da uno standby a caldo all’elemento primario che eviterà conflitti di query. | on |
| ident\$1file | Imposta il file di configurazione ident dei server. | /rdsdbdata/config/pg\$1ident.conf |
| idle\$1in\$1transaction\$1session\$1timeout | (ms) Imposta la durata massima concessa di ogni transazione inattiva. | 86400000 |
| idle\$1session\$1timeout | Termina qualsiasi sessione che è rimasta inattiva (ovvero, in attesa di una richiesta da parte del client), ma che non rientra in una transazione aperta, per un periodo di tempo specificato | – |
| join\$1collapse\$1limit | Imposta la dimensione dell’elenco FROM oltre la quale i costrutti JOIN non vengono appiattiti. | – |
| lc\$1messages | Imposta la lingua nella quale vengono visualizzati i messaggi. | – |
| listen\$1addresses | Imposta il nome host o l'indirizzo/gli indirizzi IP da ascoltare. | \$1 |
| lo\$1compat\$1privileges | Abilita la modalità di compatibilità con le versioni precedenti per i controlli dei privilegi su oggetti di grandi dimensioni. | 0 |
| log\$1connections | Registra ogni connessione riuscita. | – |
| log\$1destination | Imposta la destinazione per l’output del registro del server. | stderr |
| log\$1directory | Imposta la directory di destinazione per i file di file di log. | /rdsdbdata/log/error |
| log\$1disconnections | Registra la fine di una sessione, compresa la durata. | – |
| log\$1duration | Registra la durata di ogni istruzione SQL completata. | – |
| log\$1error\$1verbosity | Imposta la verbosità dei messaggi registrati. | – |
| log\$1executor\$1stats | Scrive le statistiche sulla prestazione degli esecutori nel registro del server. | – |
| log\$1file\$1mode | Imposta le autorizzazioni del file per i file di file di log. | 0644 |
| log\$1filename | Imposta il modello del nome del file per i file di log. | postgresql.log.%Y-%m-%d-%H%M |
| logging\$1collector | Avvia un sottoprocesso per acquisire i csvlog di output and/or di stderr in file di registro. | 1 |
| log\$1hostname | Registra il nome host nei registri delle connessioni. | 0 |
| logical\$1decoding\$1work\$1mem | (kB) Questa quantità di memoria può essere utilizzata da ogni buffer interno di riordino prima del versamento su disco. | – |
| log\$1line\$1prefix | Controlla le informazioni con prefisso su ciascuna riga di registro. | %t:%r:%u@%d:%p]: |
| log\$1lock\$1waits | Registra lunghe attese di lock. | – |
| log\$1duration\$1sample | (ms) Imposta il tempo minimo di esecuzione al di sopra del quale verrà registrato un campione di istruzioni. Il campionamento è determinato da log\$1statement\$1sample\$1rate. | – |
| log\$1min\$1duration\$1statement | (ms) Imposta il tempo minimo di esecuzione al di sopra del quale verranno registrate le istruzioni. | – |
| log\$1min\$1error\$1statement | Fa sì che tutte le istruzioni che generano un errore pari o superiore a questo livello vengano registrate. | – |
| log\$1min\$1messages | Imposta i livelli dei messaggi che vengono registrati. | – |
| log\$1parameter\$1max\$1length | (B) Quando si registrano le istruzioni, limita i valori dei parametri registrati ai primi N byte. | – |
| log\$1parameter\$1max\$1length\$1on\$1error | (B) Quando si segnala un errore, limita i valori dei parametri registrati ai primi N byte. | – |
| log\$1parser\$1stats | Scrive le statistiche sulla prestazione del decodificatore nel registro del server. | – |
| log\$1planner\$1stats | Scrive le statistiche sulla prestazione del programmatore nel registro del server. | – |
| log\$1replication\$1commands | Registra ogni comando di replica. | – |
| log\$1rotation\$1age | (min) La rotazione del file di log automatico avverrà dopo N minuti. | 60 |
| log\$1rotation\$1size | (kB) La rotazione del file di log automatico avverrà dopo N kilobyte. | 100000 |
| log\$1statement | Imposta il tipo di istruzioni registrate. | – |
| log\$1statement\$1sample\$1rate | Frazione di istruzioni che superano log\$1min\$1duration\$1sample da registrare. | – |
| log\$1statement\$1stats | Scrive le statistiche cumulative sulla prestazione nel registro del server. | – |
| log\$1temp\$1files | (kB) Registra l'uso di file temporanei più grandi di questo numero di kilobyte. | – |
| log\$1timezone | Imposta il fuso orario da utilizzare nei messaggi di registro. | UTC |
| log\$1truncate\$1on\$1rotation | Tronca i file di log esistenti con lo stesso nome durante la rotazione del registro. | 0 |
| maintenance\$1io\$1concurrency | Una variante di effective\$1io\$1concurrency utilizzata per i lavori di manutenzione. | 1 |
| maintenance\$1work\$1mem | (kB) Imposta la memoria massima da utilizzare per le operazioni di manutenzione. | MASSIMO DBInstance ClassMemory (/63963136 \$11024,65536) |
| max\$1connections | Imposta il numero massimo di connessioni simultanee. | MINIMO (DBInstanceClassMemory/9531392) 5.000 |
| max\$1files\$1per\$1process | Imposta il numero massimo di file aperti in modo simultaneo per ogni processo del server. | – |
| max\$1locks\$1per\$1transaction | Imposta il numero massimo di lock per transazione. | 64 |
| max\$1parallel\$1maintenance\$1workers | Imposta il numero massimo di processi paralleli per operazione di manutenzione. | – |
| max\$1parallel\$1workers | Imposta il numero massimo di worker paralleli che possono essere attivi in una sola volta. | MASSIMO (\$1 VCPU/2,8) DBInstance |
| max\$1parallel\$1workers\$1per\$1gather | Imposta il numero massimo di processi paralleli per nodo executor. | – |
| max\$1pred\$1locks\$1per\$1page | Imposta il numero massimo di tuple bloccate dal predicato per pagina. | – |
| max\$1pred\$1locks\$1per\$1relation | Imposta il numero massimo di pagine e tuple bloccate dal predicato per relazione. | – |
| max\$1pred\$1locks\$1per\$1transaction | Imposta il numero massimo di lock del predicato per transazione. | – |
| max\$1slot\$1wal\$1keep\$1size | (MB) Gli slot di replica saranno contrassegnati come non riusciti e i segmenti rilasciati per l'eliminazione o il riciclaggio, se questo spazio è occupato dai WAL su disco. | – |
| max\$1stack\$1depth | (kB) Imposta la profondità massima della pila in kilobyte. | 6144 |
| max\$1standby\$1streaming\$1delay | (ms) Imposta il ritardo massimo prima di annullare le query quando un server con standby a caldo elabora i dati WAL in streaming. | 14000 |
| max\$1worker\$1processes | Imposta il numero massimo di processi dipendente simultanei. | MASSIMO (\$1 DBInstance VCPU\$12,8) |
| min\$1dynamic\$1shared\$1memory | (MB) Quantità di memoria condivisa dinamica riservata all'avvio. | – |
| min\$1parallel\$1index\$1scan\$1size | (8 kB) Imposta la quantità minima di dati di indicizzazione per una scansione parallela. | – |
| min\$1parallel\$1table\$1scan\$1size | (8 kB) Imposta la quantità minima di dati della tabella per una scansione parallela. | – |
| old\$1snapshot\$1threshold | (min) Tempo prima che uno snapshot sia troppo vecchio per leggere le pagine modificate dopo l'acquisizione dello snapshot. | – |
| parallel\$1leader\$1participation | Controlla se Gather e Gather Merge eseguono anche piani secondari. | – |
| parallel\$1setup\$1cost | Imposta la stima dei pianificatori del costo di avvio dei processi dei dipendenti per la query parallela. | – |
| parallel\$1tuple\$1cost | Imposta la stima del pianificatore del costo del passaggio di ciascuna tupla (riga) dal back-end dipendente a quello principale. | – |
| pgaudit.log | Specifica quali classi di istruzioni verranno registrate per registrazione di verifica della sessione. | – |
| pgaudit.log\$1catalog | Specifica che la registrazione delle sessioni deve essere abilitata nel caso in cui tutte le relazioni in un’istruzione siano in pg\$1catalog. | – |
| pgaudit.log\$1level | Specifica il livello di log che verrà utilizzato per le voci di registro. | – |
| pgaudit.log\$1parameter | Specifica che la registrazione di log di audit deve includere i parametri passati con l’istruzione. | – |
| pgaudit.log\$1relation | Specifica se la registrazione di verifica della sessione deve creare una voce di registro separata per ogni relazione (TABLE, VIEW, ecc.) a cui fa riferimento in un'istruzione SELECT o DML. | – |
| pgaudit.log\$1statement\$1once | Speciifica se la registrazione includerà il testo e i parametri dell'istruzione con la prima voce di registro di una combinazione o con ogni voce. statement/substatement | – |
| pgaudit.role | Specifica il ruolo principale da utilizzare per la registrazione di verifica degli oggetti. | – |
| pg\$1bigm.enable\$1recheck | Specifica se eseguire Recheck, che è un processo interno di ricerca full-text. | on |
| pg\$1bigm.gin\$1key\$1limit | Specifica il numero massimo di 2-grammi della parola chiave di ricerca da utilizzare per la ricerca full-text. | 0 |
| pg\$1bigm.last\$1update | Riporta l’ultima data aggiornata del modulo pg\$1bigm. | 2013.11.22 |
| pg\$1bigm.similarity\$1limit | Specifica la soglia minima utilizzata dalla ricerca di somiglianza. | 0.3 |
| pg\$1hint\$1plan.debug\$1print | Registra i risultati dell’analisi dei suggerimenti. | – |
| pg\$1hint\$1plan.enable\$1hint | Forza il pianificatore a utilizzare i piani specificati nel commento del suggerimento precedente alla query. | – |
| pg\$1hint\$1plan.enable\$1hint\$1table | Forza il pianificatore a non ottenere indicazioni utilizzando le ricerche nella tabella. | – |
| pg\$1hint\$1plan.message\$1level | Livello di messaggio dei messaggi di debug. | – |
| pg\$1hint\$1plan.parse\$1messages | Livello di messaggio degli errori di analisi. | – |
| pglogical.batch\$1inserts | Inserimenti batch, se possibile | – |
| pglogical.conflict\$1log\$1level | Imposta il livello di registro utilizzato per la registrazione dei conflitti risolti. | – |
| pglogical.conflict\$1resolution | Imposta il metodo utilizzato per la risoluzione dei conflitti per i conflitti risolvibili. | – |
| pglogical.extra\$1connection\$1options | opzioni di connessione da aggiungere a tutte le connessioni dei nodi peer | – |
| pglogical.synchronous\$1commit | Valore di commit sincrono specifico pglogical | – |
| pglogical.use\$1spi | Usa SPI invece dell’API di basso livello per applicare le modifiche | – |
| pg\$1similarity.block\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarity.block\$1threshold | Imposta la soglia utilizzata dalla funzione di similarità dei blocchi. | – |
| pg\$1similarity.block\$1tokenizer | Imposta il tokenizzatore per la funzione di similarità dei blocchi. | – |
| pg\$1similarity.cosine\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarity.cosine\$1threshold | Imposta la soglia utilizzata dalla funzione di similarità del coseno. | – |
| pg\$1similarity.cosine\$1tokenizer | Imposta il tokenizzatore per la funzione di similarità del coseno. | – |
| pg\$1similarity.dice\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarity.dice\$1threshold | Imposta la soglia utilizzata dalla misura di similarità di Dice. | – |
| pg\$1similarity.dice\$1tokenizer | Imposta il tokenizzatore per la misura di similarità di Dice. | – |
| pg\$1similarity.euclidean\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarity.euclidean\$1threshold | Imposta la soglia utilizzata dalla misura di similarità euclidea. | – |
| pg\$1similarity.euclidean\$1tokenizer | Imposta il tokenizzatore per la misura di similarità euclidea. | – |
| pg\$1similarity.hamming\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarity.hamming\$1threshold | Imposta la soglia utilizzata dal parametro di similarità dei blocchi. | – |
| pg\$1similarity.jaccard\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarity.jaccard\$1threshold | Imposta la soglia utilizzata dalla misura di similarità di Jaccard. | – |
| pg\$1similarity.jaccard\$1tokenizer | Imposta il tokenizzatore per la misura di similarità di Jaccard. | – |
| pg\$1similarity.jaro\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarity.jaro\$1threshold | Imposta la soglia utilizzata dalla misura di similarità di Jaro. | – |
| pg\$1similarity.jarowinkler\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarity.jarowinkler\$1threshold | Imposta la soglia utilizzata dalla misura di similarità di Jarowinkler. | – |
| pg\$1similarity.levenshtein\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarity.levenshtein\$1threshold | Imposta la soglia utilizzata dalla misura di similarità di Levenshtein. | – |
| pg\$1similarity.matching\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarity.matching\$1threshold | Imposta la soglia utilizzata dalla misura di similarità del coefficiente di corrispondenza. | – |
| pg\$1similarity.matching\$1tokenizer | Imposta il tokenizzatore per la misura di similarità del coefficiente di corrispondenza. | – |
| pg\$1similarity.mongeelkan\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarity.mongeelkan\$1threshold | Imposta la soglia utilizzata dalla misura di similarità di Monge-Elkan. | – |
| pg\$1similarity.mongeelkan\$1tokenizer | Imposta il tokenizzatore per la misura di similarità di Monge-Elkan. | – |
| pg\$1similarity.nw\$1gap\$1penalty | Imposta la penalità del gap utilizzata dalla misura di similitudine di Needleman-Wunsch. | – |
| pg\$1similarity.nw\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarity.nw\$1threshold | Imposta la soglia utilizzata dalla misura di similitudine di Needleman-Wunsch. | – |
| pg\$1similarity.overlap\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarity.overlap\$1threshold | Imposta la soglia utilizzata dalla misura di similarità del coefficiente di sovrapposizione. | – |
| pg\$1similarity.overlap\$1tokenizer | Imposta il tokenizzatore per la misura di similarità del coefficiente di sovrapposizione. | – |
| pg\$1similarity.qgram\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarity.qgram\$1threshold | Imposta la soglia utilizzata dalla misura di similitudine Q-Gram. | – |
| pg\$1similarity.qgram\$1tokenizer | Imposta il tokenizzatore per la misura Q-Gram. | – |
| pg\$1similarity.swg\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarità.swg\$1threshold | Imposta la soglia utilizzata dalla misura di somiglianza Smith-Waterman-Gotoh. | – |
| pg\$1similarity.sw\$1is\$1normalized | Imposta se il valore del risultato è normalizzato o meno. | – |
| pg\$1similarity.sw\$1threshold | Imposta la soglia utilizzata dalla misura di similitudine di Smith-Waterman. | – |
| pg\$1stat\$1statements.max | Imposta il numero massimo di istruzioni monitorate da pg\$1stat\$1statements. | – |
| pg\$1stat\$1statements.save | Salva le statistiche pg\$1stat\$1statements attraverso le interruzioni del server. | – |
| pg\$1stat\$1statements.track | Seleziona le istruzioni che vengono monitorate da pg\$1stat\$1statements. | – |
| pg\$1stat\$1statements.track\$1planning | Seleziona se la durata della pianificazione è monitorata da pg\$1stat\$1statements. | – |
| pg\$1stat\$1statements.track\$1utility | Seleziona se i comandi di utilità sono monitorati da pg\$1stat\$1statements. | – |
| postgis.gdal\$1enabled\$1drivers | Abilita o disabilita i driver GDAL utilizzati con PostGIS in Postgres 9.3.5 e versioni successive. | ENABLE\$1ALL |
| quote\$1all\$1identifiers | Aggiungi le virgolette a tutti gli identificatori quando si generano i frammenti SQL. | – |
| random\$1page\$1cost | Imposta la stima del pianificatore del costo di una pagina del disco recuperata in modo non sequenziale. | – |
| rds.enable\$1memory\$1management | Migliora le funzionalità di gestione della memoria in Aurora PostgreSQL versioni 12.17, 13.13, 14.10, 15.5 e versioni successive, prevenendo i problemi di stabilità e i riavvii del database causati da una memoria libera insufficiente. Per ulteriori informazioni, consulta [Migliore gestione della memoria in Aurora PostgreSQLLimitazione](AuroraPostgreSQL.BestPractices.memory.management.md). | True |
| rds.force\$1admin\$1logging\$1level | Visualizza i messaggi di registro per le azioni dell’utente amministratore di RDS nei database dei clienti. | – |
| rds.log\$1retention\$1period | Amazon RDS elimina i registri PostgreSQL più vecchi di N minuti. | 4320 |
| rds.memory\$1allocation\$1guard | Migliora le funzionalità di gestione della memoria in Aurora PostgreSQL 11.21, 12.16, 13.12, 14.9, 15.4 e versioni precedenti, prevenendo i problemi di stabilità e i riavvii del database causati da una memoria libera insufficiente. Per ulteriori informazioni, consulta [Migliore gestione della memoria in Aurora PostgreSQLLimitazione](AuroraPostgreSQL.BestPractices.memory.management.md). | False |
| rds.pg\$1stat\$1ramdisk\$1size | Dimensioni del ramdisk delle statistiche in MB. Un valore diverso da zero configurerà il ramdisk. | 0 |
| rds.rds\$1superuser\$1reserved\$1connections | Imposta il numero di slot di connessione riservati a rds\$1superusers. Questo parametro è disponibile solo nella versione 15 e precedenti. Per ulteriori informazioni, consulta le [connessioni riservate](https://www.postgresql.org/docs/current/runtime-config-connection.html#GUC-RESERVED-CONNECTIONS) nella documentazione di PostgreSQL. | 2 |
| rds.superuser\$1variables | Elenco delle variabili del solo utente con privilegi avanzati per le quali eleviamo le istruzioni di modifica rds\$1superuser. | session\$1replication\$1role |
| remove\$1temp\$1files\$1after\$1crash | Rimuove i file temporanei dopo l'arresto anomalo del back-end | 0 |
| restart\$1after\$1crash | Reinizializza il server dopo l’arresto anomalo del back-end. | – |
| row\$1security | Abilita la sicurezza delle righe. | – |
| search\$1path | Imposta l’ordine di ricerca dello schema per i nomi che non sono qualificati come schema. | – |
| seq\$1page\$1cost | Imposta la stima del pianificatore del costo di una pagina del disco recuperata in modo sequenziale. | – |
| session\$1replication\$1role | Imposta il comportamento delle sessioni per i trigger e le regole di riscrittura. | – |
| shared\$1buffers | (8 kB) Imposta il numero di buffer di memoria condivisa utilizzati dal server. | SOMMA (DBInstanceClassMemory/12038, -50003) |
| shared\$1preload\$1libraries | Elenca le librerie condivise da precaricare nel server. | pg\$1stat\$1statements |
| ssl\$1ca\$1file | Posizione del file dell’autorità del server SSL. | /-cert.pem rdsdbdata/rds-metadata/ca |
| ssl\$1cert\$1file | Posizione del file del certificato del server SSL. | /rdsdbdata/rds-metadata/server-cert.pem |
| ssl\$1crl\$1dir | Posizione della directory dell'elenco di revoche di certificati SSL. | /rdsdbdata/rds-metadata/ssl\$1crl\$1dir/ |
| ssl\$1key\$1file | Posizione del file della chiave privata del server SSL | /rdsdbdata/rds-metadata/server-chiave.pem |
| standard\$1conforming\$1strings | Fa sì che le stringhe ... trattino letteralmente le barre rovesciate. | – |
| statement\$1timeout | (ms) Imposta la durata massima concessa di ogni istruzione. | – |
| stats\$1temp\$1directory | Scrive i file di statistiche temporanei nella directory specificata. | /rdsdbdata/db/pg\$1stat\$1tmp |
| superuser\$1reserved\$1connections | Imposta il numero di slot di connessione riservati agli utenti con privilegi avanzati. | 3 |
| synchronize\$1seqscans | Abilita le scansioni sequenziali sincronizzate. | – |
| tcp\$1keepalives\$1count | Numero massimo di ritrasmissioni keepalive TCP. | – |
| tcp\$1keepalives\$1idle | (s) Tempo tra l'emissione di keepalive TCP. | – |
| tcp\$1keepalives\$1interval | (s) Tempo tra la ritrasmissione di keepalive TCP. | – |
| temp\$1buffers | (8 kB) Imposta il numero massimo di buffer temporanei utilizzati da ogni sessione. | – |
| temp\$1file\$1limit | Vincola la quantità totale di spazio su disco in kilobyte che un determinato processo PostgreSQL può utilizzare per i file temporanei, escludendo lo spazio utilizzato per tabelle temporanee esplicite | -1 |
| temp\$1tablespaces | Imposta i tablespace da usare per le tabelle temporanee e i file di ordinamento. | – |
| track\$1activities | Raccoglie informazioni sui comandi di esecuzione. | – |
| track\$1activity\$1query\$1size | Imposta la dimensione riservata per pg\$1stat\$1activity.current\$1query, in byte. | 4096 |
| track\$1counts | Raccoglie statistiche sull’attività del database. | – |
| track\$1functions | Raccoglie statistiche a livello di funzione sull’attività del database. | pl |
| track\$1io\$1timing | Raccoglie statistiche di temporizzazione sull’attività di I/O del database. | 1 |
| transform\$1–\$1equals | Treats expr=– as expr IS –. | – |
| update\$1process\$1title | Aggiorna il titolo del processo per mostrare il comando SQL attivo. | – |
| wal\$1receiver\$1status\$1interval | (s) Imposta l'intervallo massimo tra i report di stato del ricevitore WAL al nodo primario. | – |
| work\$1mem | (kB) Imposta la memoria massima da utilizzare per gli spazi di lavoro delle query. | – |
| xmlbinary | Imposta come i valori binari devono essere codificati in XML. | – |
| xmloption | Imposta se i dati XML nelle operazioni di analisi e serializzazione implicite devono essere considerati come documenti o frammenti di contenuto. | – |
# Eventi di attesa Amazon Aurora PostgreSQL
Di seguito sono riportati alcuni tra gli eventi di attesa più frequenti di Aurora PostgreSQL. Per ulteriori informazioni sugli eventi di attesa e l’ottimizzazione del cluster database Aurora PostgreSQL, consulta [Sintonizzazione degli eventi di attesa per Aurora PostgreSQL](AuroraPostgreSQL.Tuning.md).
**Attività: ArchiverMain**
Il processo di archiviazione è in attesa di attività.
**Attività: AutoVacuumMain**
Il processo del programma di avvio di autovacuum è in attesa di attività.
**Attività: BgWriterHibernate**
Il processo di scrittura in background è in ibernazione in attesa dell'attività.
**Attività: BgWriterMain**
Il processo di scrittura in background è in attesa di attività.
**Attività: CheckpointerMain**
Il processo di checkpointer è in attesa di attività.
**Attività: LogicalApplyMain**
Il processo di applicazione della replica logica è in attesa di attività.
**Attività: LogicalLauncherMain**
Il processo di avvio della replica logica è in attesa di attività.
**Attività: PgStatMain**
Il processo di raccolta statistiche è in attesa di attività.
**Attività: RecoveryWalAll**
Un processo è in attesa del WAL (write-ahead log) da un flusso al momento del ripristino.
**Attività: RecoveryWalStream**
Il processo di avvio è in attesa che il WAL (write-ahead log) arrivi durante il ripristino dello streaming.
**Attività: SysLoggerMain**
Il processo syslogger è in attesa di attività.
**Attività: WalReceiverMain**
Il processo WAL (write-ahead log) del destinatario è in attesa di attività.
**Attività: WalSenderMain**
Il processo WAL (write-ahead log) del mittente è in attesa di attività.
**Attività: WalWriterMain**
Il processo di scrittura WAL (write-ahead log) è in attesa di attività.
**BufferPin:BufferPin**
Un processo è in attesa di acquisire un pin esclusivo su un buffer.
**Client: GSSOpen Server**
Un processo è in attesa di leggere i dati dal client nel tentativo di stabilire una sessione GSSAPI (Generic Security Service Application Program Interface).
**Cliente: ClientRead**
Un processo di backend è in attesa di ricevere dati da un client PostgreSQL. Per ulteriori informazioni, consulta [Cliente: ClientRead](apg-waits.clientread.md).
**Cliente: ClientWrite**
Un processo di backend è in attesa di inviare più dati a un client PostgreSQL. Per ulteriori informazioni, consulta [Cliente: ClientWrite](apg-waits.clientwrite.md).
**Cliente: Lib PQWal ReceiverConnect**
Un processo è in attesa nel destinatario WAL (write-ahead log) per stabilire la connessione al server remoto.
**Cliente: Lib PQWal ReceiverReceive**
Un processo è in attesa nel destinatario WAL (write-ahead log) per ricevere i dati dal server remoto.
**Cliente: Server SSLOpen**
Un processo è in attesa di Secure Sockets Layer (SSL) durante il tentativo di connessione.
**Cliente: WalReceiverWaitStart**
Un processo è in attesa che il processo di avvio invii i dati iniziali per la replica in streaming.
**Cliente: WalSenderWaitFor WAL**
Un processo è in attesa che il WAL (write-ahead log) venga svuotato nel processo mittente WAL.
**Cliente: WalSenderWriteData**
Un processo è in attesa di qualsiasi attività durante l'elaborazione delle risposte dal destinatario WAL (write-ahead log) nel processo mittente WAL.
**CPU**
Un processo di backend è attivo o è in attesa della CPU. Per ulteriori informazioni, consulta [CPU](apg-waits.cpu.md).
**Extension:extension**
Un processo di backend è in attesa di una condizione definita da un'estensione o da un modulo.
**IO: AuroraEnhancedLogical WALRead**
Un processo di backend sta recuperando i record di log dal volume CDC (Change Data Capture).
**IO: AuroraOptimizedReadsCacheRead**
Un processo è in attesa di una lettura dalla cache a più livelli di Letture ottimizzate perché la pagina non è disponibile nella memoria condivisa.
**IO: AuroraOptimizedReads CacheSegmenttronca**
Un processo è in attesa che un file di segmento della cache a più livelli di Letture ottimizzate venga troncato.
**IO: AuroraOptimizedReadsCacheWrite**
Il processo di scrittura in background è in attesa di scrivere nella cache a più livelli di Letture ottimizzate.
**IO: AuroraStorageLogAllocate**
Una sessione sta allocando i metadati e si sta preparando per la scrittura nel registro delle transazioni.
**IO: BufFileRead**
Quando le operazioni richiedono più memoria della quantità definita dai parametri di memoria di lavoro, il motore crea file temporanei su disco. Questo evento di attesa si verifica quando le operazioni vengono lette dai file temporanei. Per ulteriori informazioni, consulta [IO: BufFileRead e IO: BufFileWrite](apg-waits.iobuffile.md).
**IO: BufFileWrite**
Quando le operazioni richiedono più memoria della quantità definita dai parametri di memoria di lavoro, il motore crea file temporanei su disco. Questo evento di attesa si verifica quando le operazioni scrivono nei file temporanei. Per ulteriori informazioni, consulta [IO: BufFileRead e IO: BufFileWrite](apg-waits.iobuffile.md).
**IO: ControlFileRead**
Un processo è in attesa di una lettura dal file `pg_control`.
**IO: ControlFileSync**
Un processo è in attesa del file `pg_control` per raggiungere un’archiviazione durevole.
**IO: ControlFileSyncUpdate**
Un processo è in attesa di un aggiornamento del file `pg_control` per raggiungere un’archiviazione durevole.
**IO: ControlFileWrite**
Un processo è in attesa di una scrittura sul file `pg_control`.
**IO: ControlFileWriteUpdate**
Un processo è in attesa di una scrittura per aggiornare il file `pg_control`.
**IO: CopyFileRead**
Un processo è in attesa di una lettura durante un'operazione di copia dei file.
**IO: CopyFileWrite**
Un processo è in attesa di una scrittura durante un'operazione di copia dei file.
**IO: DataFileExtend**
Un processo è in attesa dell'estensione di un file di dati di relazione.
**IO: DataFileFlush**
Un processo è in attesa che un file di dati di relazione raggiunga un’archiviazione durevole.
**IO: DataFileImmediateSync**
Un processo è in attesa di una sincronizzazione immediata di un file di dati di relazione a un’archiviazione durevole.
**IO: DataFilePrefetch**
Un processo è in attesa di un prefetch asincrono da un file di dati di relazione.
**IO: DataFileSync**
Un processo è in attesa di modifiche a un file di dati di relazione per raggiungere un’archiviazione durevole.
**IO: DataFileRead**
Un processo di back-end ha cercato di trovare una pagina nei buffer condivisi, non l'ha trovata e quindi l'ha letta dall’archiviazione. Per ulteriori informazioni, consulta [IO: DataFileRead](apg-waits.iodatafileread.md).
**IO: DataFileTruncate**
Un processo è in attesa che un file di dati di relazione venga troncato.
**IO: DataFileWrite**
Un processo è in attesa di una scrittura su un file di dati di relazione.
**IO: DSMFill ZeroWrite**
Un processo è in attesa di scrivere zero byte su un file dinamico di backup della memoria condivisa.
**IO: LockFileAddToDataDirRead**
Un processo è in attesa di una lettura durante l’aggiunta di una riga al file da bloccare della directory dati.
**IO: LockFileAddToDataDirSync**
Un processo è in attesa che i dati raggiungano un’archiviazione durevole durante l’aggiunta di una riga al file da bloccare della directory dati.
**IO: LockFileAddToDataDirWrite**
Un processo è in attesa di scrittura durante l’aggiunta di una riga al file da bloccare della directory dati.
**IO: LockFileCreateRead**
Un processo è in attesa di lettura durante la creazione del file da bloccare della directory dati.
**IO: LockFileCreateSync**
Un processo è in attesa che i dati raggiungano un’archiviazione durevole durante la creazione del file da bloccare della directory dati.
**IO: LockFileCreateWrite**
Un processo è in attesa di scrittura durante la creazione del file da bloccare della directory dati.
**IO: LockFileReCheckDataDirRead**
Un processo è in attesa di una lettura durante il ricontrollo del file da bloccare della directory dati.
**IO: LogicalRewriteCheckpointSync**
Un processo è in attesa che le mappature di riscrittura logica raggiungano un’archiviazione durevole durante un checkpoint.
**IO: LogicalRewriteMappingSync**
Un processo è in attesa che i dati di mappatura raggiungano un’archiviazione durevole durante una riscrittura logica.
**IO: LogicalRewriteMappingWrite**
Un processo è in attesa di una scrittura dei dati di mappatura durante una riscrittura logica.
**IO: LogicalRewriteSync**
Un processo è in attesa che le mappature di riscrittura logica raggiungano un’archiviazione durevole.
**IO: LogicalRewriteTruncate**
Un processo è in attesa del troncamento dei dati di mappatura durante una riscrittura logica.
**IO: LogicalRewriteWrite**
Un processo è in attesa di una scrittura di mappature di riscrittura logica.
**IO: RelationMapRead**
Un processo è in attesa di una lettura del file di mappa della relazione.
**IO: RelationMapSync**
Un processo è in attesa che il file di mappa della relazione raggiunga un’archiviazione durevole.
**IO: RelationMapWrite**
Un processo è in attesa di una scrittura sul file di mappatura della relazione.
**IO: ReorderBufferRead**
Un processo è in attesa di una lettura durante la gestione del buffer da riordinare.
**IO: ReorderBufferWrite**
Un processo è in attesa di una scrittura durante la gestione del buffer da riordinare.
**IO: ReorderLogicalMappingRead**
Un processo è in attesa di una lettura di una mappatura logica durante la gestione del buffer da riordinare.
**IO: ReplicationSlotRead**
Un processo è in attesa di una lettura da un file di controllo dello slot di replica.
**IO: ReplicationSlotRestoreSync**
Un processo è in attesa che un file di controllo dello slot di replica raggiunga un’archiviazione durevole durante il ripristino in memoria.
**IO: ReplicationSlotSync**
Un processo è in attesa che un file di controllo dello slot di replica raggiunga un’archiviazione durevole.
**IO: ReplicationSlotWrite**
Un processo è in attesa di una scrittura su un file di controllo dello slot di replica.
**IO: SLRUFlush sincronizzazione**
Un processo è in attesa che i dati semplici utilizzati meno di recente (SLRU) raggiungano un’archiviazione durevole durante un checkpoint o uno spegnimento del database.
**IO: SLRURead**
Un processo è in attesa di una lettura di una pagina semplice utilizzata meno di recente (SLRU).
**IO: SLRUSync**
Un processo è in attesa che i dati semplici utilizzati meno di recente (SLRU) raggiungano un’archiviazione durevole dopo la scrittura di una pagina.
**IO: SLRUWrite**
Un processo è in attesa della scrittura di una pagina semplice utilizzata meno di recente (SLRU).
**IO: SnapbuildRead**
Un processo è in attesa di una lettura di uno snapshot del catalogo storico serializzato.
**IO: SnapbuildSync**
Un processo è in attesa che uno snapshot del catalogo storico serializzato raggiunga un’archiviazione durevole.
**IO: SnapbuildWrite**
Un processo è in attesa della scrittura di uno snapshot del catalogo storico serializzato.
**IO: TimelineHistoryFileSync**
Un processo è in attesa che un file della cronologia della timeline ricevuto tramite la replica in streaming raggiunga un’archiviazione durevole.
**IO: TimelineHistoryFileWrite**
Un processo è in attesa di una scrittura di un file di cronologia della timeline ricevuto tramite la replica in streaming.
**IO: TimelineHistoryRead**
Un processo è in attesa di una lettura di un file cronologico della timeline.
**IO: TimelineHistorySync**
Un processo è in attesa che un file cronologico della timeline appena creato raggiunga un’archiviazione durevole.
**IO: TimelineHistoryWrite**
Un processo è in attesa di una scrittura di un file di cronologia della timeline appena creato.
**IO: TwophaseFileRead**
Un processo è in attesa di una lettura di un file di stato in due fasi.
**IO: TwophaseFileSync**
Un processo è in attesa che un file di stato in due fasi raggiunga un’archiviazione durevole.
**IO: TwophaseFileWrite**
Un processo è in attesa di scrittura di un file di stato in due fasi.
**IO: WALBootstrap sincronizzazione**
Un processo è in attesa che il WAL (write-ahead log) raggiunga un’archiviazione durevole durante il processo di bootstrap.
**IO: WALBootstrap Scrivi**
Un processo è in attesa di scrittura di una pagina WAL (write-ahead log) durante il processo di bootstrap.
**IO: WALCopy Leggi**
Un processo è in attesa di una lettura durante la creazione di un nuovo segmento WAL (write-ahead log) tramite copia di uno esistente.
**IO: WALCopy sincronizzazione**
Un processo è in attesa di un nuovo segmento WAL (write-ahead log) creato tramite copia di uno esistente per raggiungere un’archiviazione durevole.
**IO: WALCopy Scrivi**
Un processo è in attesa di una scrittura quando si crea un nuovo segmento WAL (write-ahead log) tramite copia di uno esistente.
**IO: WALInit sincronizzazione**
Un processo è in attesa che un file WAL (write-ahead log) di recente inizializzazione raggiunga l’archiviazione durevole.
**IO: WALInit Scrivi**
Un processo è in attesa di una scrittura durante l'inizializzazione di un nuovo file WAL (write-ahead log).
**IO: WALRead**
Un processo è in attesa di una lettura da un file WAL (write-ahead log).
**IO: WALSender TimelineHistoryRead**
Un processo è in attesa di una lettura da un file cronologico della timeline durante un comando della timeline del mittente WAL (write-ahead log).
**IO: WALSync**
Un processo è in attesa che un file WAL (write-ahead log) raggiunga un’archiviazione durevole.
**IO: WALSync MethodAssign**
Un processo è in attesa che i dati raggiungano un’archiviazione durevole durante l'assegnazione di un nuovo metodo di sincronizzazione WAL (write-ahead log).
**IO: WALWrite**
Un processo è in attesa di una scrittura su un file WAL (write-ahead log).
**IO: XactSync**
Un processo di backend è in attesa che il sottosistema archiviazione Aurora riconosca il commit di una transazione regolare o il commit o il rollback di una transazione preparata. Per ulteriori informazioni, consulta [IO:XactSync](apg-waits.xactsync.md).
**IPC: AuroraLogicalSchemaUpdate**
Due processi di backend stanno tentando di inserire la stessa voce nella cache dello schema. Un processo continuerà mentre l’altro attende il completamento.
**IPC: AuroraOptimizedReadsCacheWriteStop**
Un processo è in attesa che l’istanza di scrittura in background interrompa la scrittura nella cache a più livelli di letture ottimizzate.
**IPC: BackupWaitWalArchive**
Un processo è in attesa dei file WAL (write-ahead log) necessari per l’archiviazione corretta di un backup.
**IPC: BgWorkerShutdown**
Un processo è in attesa dell’arresto del lavoro in background.
**IPC: BgWorkerStartup**
Un processo è in attesa dell'avvio di un lavoro in background.
**IPC: BtreePage**
Un processo è in attesa che il numero di pagina necessario per continuare la scansione parallela del B-tree diventi disponibile.
**IPC: CheckpointDone**
Un processo è in attesa del completamento di un checkpoint.
**IPC: CheckpointStart**
Un processo è in attesa dell’avvio di un checkpoint.
**IPC: ClogGroupUpdate**
Un processo è in attesa che il leader del gruppo aggiorni lo stato della transazione al termine di una transazione.
**IPC: DamRecordTxAck**
Un processo di backend ha generato un evento di flussi di attività del database ed è in attesa che l'evento diventi durevole. Per ulteriori informazioni, consulta [IPC:DamRecordTxAck](apg-waits.ipcdamrecordtxac.md).
**IPC: ExecuteGather**
Un processo è in attesa di attività da un processo figlio durante l'esecuzione di un nodo del piano Gather.
**IPC: Hash/Batch/Allocating**
Un processo è in attesa dell’allocazione di una tabella hash da parte di un partecipante all’hash parallelo eletto.
**IPC: Hash/Batch/Electing**
Un processo sta eleggendo un partecipante all’hash parallelo per allocare una tabella hash.
**IPC: Hash/Batch/Loading**
Un processo è in attesa che altri partecipanti all’hash parallelo finiscano il caricamento di una tabella hash.
**IPC: Hash/Build/Allocating**
Un processo è in attesa dell’allocazione della tabella hash iniziale da parte di un partecipante all’hash parallelo eletto.
**IPC: Hash/Build/Electing**
Un processo sta eleggendo un partecipante all’hash parallelo per allocare la tabella hash iniziale.
**IPC: Hash/Build/HashingInner**
Un processo è in attesa che altri partecipanti all’hash parallelo finiscano di eseguire l'hashing della relazione interna.
**IPC: Hash/Build/HashingOuter**
Un processo è in attesa che altri partecipanti all’hash parallelo finiscano il partizionamento della relazione esterna.
**IPC: Hash/GrowBatches/Allocating**
Un processo è in attesa dell’allocazione di più batch da parte di un partecipante all’hash parallelo eletto.
**IPC: Hash/GrowBatches/Deciding**
Un processo sta eleggendo un partecipante all'hash parallelo per decidere sull’aumento futuro dei batch.
**IPC: Hash/GrowBatches/Electing**
Un processo sta eleggendo un partecipante all’hash parallelo per l’allocazione di più batch.
**IPC: Hash/GrowBatches/Finishing**
Un processo è in attesa che un partecipante all'hash parallelo eletto decida sulla crescita futura dei batch.
**IPC: Hash/GrowBatches/Repartitioning**
Un processo è in attesa che altri partecipanti all'hash parallelo finiscano il ripartizionamento.
**IPC: Hash/GrowBuckets/Allocating**
Un processo è in attesa che un partecipante all’hash parallelo eletto finisca l’allocazione di più bucket.
**IPC: Hash/GrowBuckets/Electing**
Un processo sta eleggendo un partecipante all’hash parallelo per l’allocazione di più bucket.
**IPC: Hash/GrowBuckets/Reinserting**
Un processo è in attesa che altri partecipanti all'hash parallelo finiscano di inserire tuple in nuovi bucket.
**IPC: HashBatchAllocate**
Un processo è in attesa dell’allocazione di una tabella hash da parte di un partecipante all’hash parallelo eletto.
**IPC: HashBatchElect**
Un processo è in attesa di eleggere un partecipante all’hash parallelo per allocare una tabella hash.
**IPC: HashBatchLoad**
Un processo è in attesa che altri partecipanti all’hash parallelo finiscano il caricamento di una tabella hash.
**IPC: HashBuildAllocate**
Un processo è in attesa dell’allocazione della tabella hash iniziale da parte di un partecipante all’hash parallelo eletto.
**IPC: HashBuildElect**
Un processo è in attesa di eleggere un partecipante all’hash parallelo per allocare la tabella hash iniziale.
**IPC: HashBuildHashInner**
Un processo è in attesa che altri partecipanti all’hash parallelo finiscano di eseguire l'hashing della relazione interna.
**IPC:» HashBuildHashOuter**
Un processo è in attesa che altri partecipanti all’hash parallelo finiscano il partizionamento della relazione esterna.
**IPC: HashGrowBatchesAllocate**
Un processo è in attesa dell’allocazione di più batch da parte di un partecipante all’hash parallelo eletto.
**IPC:» HashGrowBatchesDecide**
Un processo è in attesa di eleggere un partecipante all'hash parallelo per decidere sulla crescita futura dei batch.
**IPC: HashGrowBatchesElect**
Un processo è in attesa di eleggere un partecipante all’hash parallelo per allocare più batch.
**IPC: HashGrowBatchesFinish**
Un processo è in attesa che un partecipante all'hash parallelo eletto decida sulla crescita futura dei batch.
**IPC: HashGrowBatchesRepartition**
Un processo è in attesa che altri partecipanti all'hash parallelo finiscano il ripartizionamento.
**IPC: HashGrowBucketsAllocate**
Un processo è in attesa che un partecipante all’hash parallelo eletto finisca l’allocazione di più bucket.
**IPC: HashGrowBucketsElect**
Un processo è in attesa di eleggere un partecipante all’hash parallelo per allocare più bucket.
**IPC: HashGrowBucketsReinsert**
Un processo è in attesa che altri partecipanti all'hash parallelo finiscano di inserire tuple in nuovi bucket.
**IPC: LogicalSyncData**
Un processo è in attesa che un server remoto di replica logica invii dati per la sincronizzazione iniziale della tabella.
**IPC: LogicalSyncStateChange**
Un processo è in attesa che un server remoto di replica logica modifichi lo stato.
**IPC: MessageQueueInternal**
Un processo è in attesa che un altro processo sia allegato a una coda di messaggi condivisa.
**IPC: MessageQueuePutMessage**
Un processo è in attesa di scrivere un messaggio di protocollo in una coda di messaggi condivisa.
**IPC: MessageQueueReceive**
Un processo è in attesa di ricevere byte da una coda di messaggi condivisa.
**IPC: MessageQueueSend**
Un processo è in attesa di inviare byte a una coda di messaggi condivisa.
**IPC: ParallelBitmapScan**
Un processo è in attesa di inizializzazione da parte di una scansione bitmap parallela.
**IPC: ParallelCreateIndexScan**
Un processo è in attesa che i lavori CREATE INDEX (CREA INDICE) paralleli finiscano una scansione heap.
**IPC: ParallelFinish**
Un processo è in attesa che i lavori paralleli finiscano l'elaborazione.
**IPC: ProcArrayGroupUpdate**
Un processo è in attesa che il leader del gruppo cancelli l’ID transazione al termine di una transazione.
**IPC: ProcSignalBarrier**
Un processo è in attesa che un evento barriera venga elaborato da tutti i backend.
**IPC:Promote**
Un processo è in attesa di una promozione in standby.
**IPC: RecoveryConflictSnapshot**
Un processo è in attesa della risoluzione dei conflitti di ripristino per una pulizia vacuum.
**IPC: RecoveryConflictTablespace**
Un processo è in attesa della risoluzione dei conflitti di ripristino per l'eliminazione di uno spazio di tabella.
**IPC: RecoveryPause**
Un processo è in attesa di riavvio del ripristino.
**IPC: ReplicationOriginDrop**
Un processo è in attesa che un'origine di replica diventi inattiva in modo che possa essere eliminata.
**IPC: ReplicationSlotDrop**
Un processo è in attesa che uno slot di replica diventi inattivo in modo che possa essere eliminato.
**IPC: SafeSnapshot**
Un processo è in attesa di ottenere uno snapshot valido per una transazione READ ONLY DEFERRABLE (SOLA LETTURA DIFFERIBILE).
**IPC: SyncRep**
Un processo è in attesa di conferma da un server remoto durante la replica sincrona.
**IPC: XactGroupUpdate**
Un processo è in attesa che il leader del gruppo aggiorni lo stato della transazione al termine di una transazione.
**Lock:advisory**
Un processo di back-end è in attesa del blocco di consulenza che ha richiesto. Per ulteriori informazioni, consulta [Lock:advisory](apg-waits.lockadvisory.md).
**Lock:extend**
Un processo di backend è in attesa del rilascio di un blocco in modo che possa estendere una relazione. Questo blocco è necessario perché solo un processo di back-end può estendere una relazione alla volta. Per ulteriori informazioni, consulta [Lock:extend](apg-waits.lockextend.md).
**Lock:frozenid**
Un processo è in attesa di aggiornare `pg_database.datfrozenxid` e `pg_database.datminmxid`.
**Lock:object**
Un processo è in attesa di ottenere un blocco su un oggetto di database non relazionale.
**Lock:page**
Un processo è in attesa di ottenere un blocco su una pagina di una relazione.
**Lock:Relation**
Un processo di backend è in attesa di acquisire un blocco su una relazione bloccata da un'altra transazione. Per ulteriori informazioni, consulta [Lock:Relation](apg-waits.lockrelation.md).
**Lock:spectoken**
Un processo è in attesa di ottenere un blocco di inserimento speculativo.
**Token Lock:speculative**
Un processo è in attesa di acquisire un blocco di inserimento speculativo.
**Lock:transactionid**
Una transazione è in attesa di un blocco a livello di riga. Per ulteriori informazioni, consulta [Lock:transactionid](apg-waits.locktransactionid.md).
**Lock:tuple**
Un processo di backend è in attesa di acquisire un blocco su una tupla mentre un altro processo di backend tiene un blocco in conflitto sulla stessa tupla. Per ulteriori informazioni, consulta [Lock:tuple](apg-waits.locktuple.md).
**Lock:userlock**
Un processo è in attesa di ottenere un blocco utente.
**Lock:virtualxid**
Un processo è in attesa di ottenere un blocco ID di transazione virtuale.
**LWLock:AddinShmemInit**
Un processo è in attesa di gestire l'allocazione dello spazio di un'estensione nella memoria condivisa.
**LWLock:AddinShmemInitLock**
Un processo è in attesa di gestire l'allocazione dello spazio nella memoria condivisa.
**LWLockIPC: ----sep----:async**
Un processo è in attesa I/O su un buffer asincrono (notify).
**LWLock:AsyncCtlLock**
Un processo è in attesa di leggere o aggiornare uno stato di notifica condiviso.
**LWLock:AsyncQueueLock**
Un processo è in attesa di leggere o aggiornare i messaggi di notifica.
**LWLock:AuroraOptimizedReadsCacheMapping**
Un processo è in attesa di associare un blocco di dati a una pagina nella cache a più livelli di Letture ottimizzate.
**LWLock:AutoFile**
Un processo è in attesa di aggiornare il file `postgresql.auto.conf`.
**LWLock:AutoFileLock**
Un processo è in attesa di aggiornare il file `postgresql.auto.conf`.
**LWLockUn processo è in attesa su un buffer asincrono (notifica). ----sep----:AutoVacuum**
Un processo è in attesa di leggere o aggiornare lo stato attuale dei lavori autovacuum.
**LWLock:AutovacuumLock**
Un lavoro o un programma di avvio autovacuum è in attesa di aggiornare o leggere lo stato attuale dei lavori autovacuum.
**LWLock:AutovacuumSchedule**
Un processo è in attesa di garantire che una tabella selezionata per l'autovacuum necessita ancora di vacuum.
**LWLock:AutovacuumScheduleLock**
Un processo è in attesa di garantire che la tabella selezionata per il vacuum necessiti ancora di vacuum.
**LWLock:BackendRandomLock**
Un processo è in attesa di generare un numero casuale.
**LWLock:BackgroundWorker**
Un processo è in attesa di leggere o aggiornare lo stato del lavoro in background.
**LWLock:BackgroundWorkerLock**
Un processo è in attesa di leggere o aggiornare lo stato del lavoro in background.
**LWLock:BtreeVacuum**
Un processo è in attesa di leggere o aggiornare le informazioni relative al vacuum per un indice B-tree.
**LWLock:BtreeVacuumLock**
Un processo è in attesa di leggere o aggiornare le informazioni relative al vacuum per un indice B-tree.
**LWLock:Autovacuum ----sep----:buffer\$1content**
Un processo di backend è in attesa di acquisire un blocco leggero sui contenuti di un buffer di memoria condiviso. Per ulteriori informazioni, consulta [LWLock:contenuto\$1buffer () BufferContent](apg-waits.lockbuffercontent.md).
**LWLock:buffer\$1content ----sep----:buffer\$1mapping**
Un processo di backend è in attesa di associare un blocco di dati a un buffer nel pool di buffer condiviso. Per ulteriori informazioni, consulta [LWLock:mappatura\$1buffer](apg-waits.lwl-buffer-mapping.md).
**LWLock:buffer\$1mapping ----Sep----:Bufferio**
Un processo di back-end vuole leggere una pagina nella memoria condivisa. Il processo è in attesa che gli altri processi finiscano I/O la pagina. Per ulteriori informazioni, consulta [LWLock:BufferIO (IPC:BufferIO)](apg-waits.lwlockbufferio.md).
**LWLockIl processo è in attesa che altri processi finiscano la pagina. ----sep----:Checkpoint**
Un processo è in attesa di iniziare un checkpoint.
**LWLock:CheckpointLock**
Un processo è in attesa di eseguire il checkpoint.
**LWLock:CheckpointerComm**
Un processo è in attesa di gestire le richieste `fsync`.
**LWLock:CheckpointerCommLock**
Un processo è in attesa di gestire le richieste `fsync`.
**LWLock:Punto di controllo ----sep----:zoccolo**
Un processo è in attesa I/O su un buffer di clog (status della transazione).
**LWLock:CLogControlLock**
Un processo è in attesa di leggere o aggiornare lo stato della transazione.
**LWLock:CLogTruncationLock**
Un processo è in attesa di eseguire `txid_status` o di aggiornare l’ID di transazione meno recente disponibile.
**LWLockUn processo è in attesa su un buffer di clog (status della transazione). ----sep----:commit\$1timestamp**
Un processo è in attesa su un buffer di timestamp di I/O commit.
**LWLock:CommitTs**
Un processo è in attesa di leggere o aggiornare l'ultimo valore impostato per un timestamp commit della transazione.
**LWLock:CommitTsBuffer**
Un processo è in attesa di un timestamp di I/O commit su un semplice buffer SLRU (Least-Recently Used).
**LWLock:CommitTsControlLock**
Un processo è in attesa di leggere o aggiornare i timestamp commit della transazione.
**LWLock:CommitTsLock**
Un processo è in attesa di leggere o aggiornare l'ultimo valore impostato per il timestamp della transazione.
**LWLockCommitTs: SLRU**
Un processo è in attesa di accedere alla cache semplice utilizzata meno di recente (SLRU) per un timestamp commit.
**LWLock:ControlFile**
Un processo è in attesa di leggere o aggiornare il file `pg_control` o di creare un nuovo file WAL (write-ahead log).
**LWLock:ControlFileLock**
Un processo è in attesa di leggere o aggiornare il control file o la creazione di un nuovo file WAL (write-ahead log).
**LWLock:DynamicSharedMemoryControl**
Un processo è in attesa di leggere o aggiornare le informazioni dinamiche di allocazione della memoria condivisa.
**LWLock:DynamicSharedMemoryControlLock**
Un processo è in attesa di leggere o aggiornare lo stato dinamico della memoria condivisa.
**LWLock: SLRU ----sep----:lock\$1manager**
Un processo di backend è in attesa di aggiungere o esaminare i blocchi per i processi di backend. Oppure è in attesa di unirsi o uscire da un gruppo di blocco utilizzato dalla query parallela. Per ulteriori informazioni, consulta [LWLock:lock\$1manager](apg-waits.lw-lock-manager.md).
**LWLock:LockFastPath**
Un processo è in attesa di leggere o aggiornare le informazioni di blocco del percorso rapido di un processo.
**LWLock:LogicalRepWorker**
Un processo è in attesa di leggere o aggiornare lo stato dei lavori di replica logica.
**LWLock:LogicalRepWorkerLock**
Un processo è in attesa del termine di un’azione su un lavoro di replica logica.
**LWLock:LogicalSchemaCache**
Un processo ha modificato la cache dello schema.
**LWLock:lock\$1manager ----sep----:multixact\$1member**
Un processo è in attesa su un buffer multixact\$1member I/O .
**LWLockUn processo è in attesa su un buffer multixact\$1member. ----sep----:multixact\$1offset**
Un processo è in attesa su un buffer di offset multixact I/O .
**LWLock:MultiXactGen**
Un processo è in attesa di leggere o aggiornare lo stato multixact condiviso.
**LWLock:MultiXactGenLock**
Un processo è in attesa di leggere o aggiornare uno stato multixact condiviso.
**LWLock:MultiXactMemberBuffer**
Un processo è in attesa I/O su un buffer SLRU (Simple Least-Recently Used) per un membro multixact. Per ulteriori informazioni, consulta [LWLock:MultiXact](apg-waits.lwlockmultixact.md).
**LWLock:MultiXactMemberControlLock**
Un processo è in attesa di leggere o aggiornare le mappature dei membri multixact.
**LWLockMultiXactMember: SLRU**
Un processo è in attesa di accedere alla cache semplice utilizzata meno di recente (SLRU) per un membro multixact. Per ulteriori informazioni, consulta [LWLock:MultiXact](apg-waits.lwlockmultixact.md).
**LWLock:MultiXactOffsetBuffer**
Un processo è in attesa di un offset I/O multixact su un semplice buffer SLRU (Least-Recently Used). Per ulteriori informazioni, consulta [LWLock:MultiXact](apg-waits.lwlockmultixact.md).
**LWLock:MultiXactOffsetControlLock**
Un processo è in attesa di leggere o aggiornare le mappature offset multixact.
**LWLockMultiXactOffset: SLRU**
Un processo è in attesa di accedere alla cache semplice utilizzata meno di recente (SLRU) per un offset multixact. Per ulteriori informazioni, consulta [LWLock:MultiXact](apg-waits.lwlockmultixact.md).
**LWLock:MultiXactTruncation**
Un processo è in attesa di leggere o troncare informazioni multixact.
**LWLock:MultiXactTruncationLock**
Un processo è in attesa di leggere o troncare informazioni multixact.
**LWLock:NotifyBuffer**
Un processo è in attesa di un messaggio NOTIFY I/O sul buffer Simple Least-Recently Used (SLRU).
**LWLock:NotifyQueue**
Un processo è in attesa di leggere o aggiornare i messaggi NOTIFY (NOTIFICA).
**LWLock:NotifyQueueTail**
Un processo è in attesa di aggiornare un limite per l’archiviazione dei messaggi NOTIFY (NOTIFICA).
**LWLock:NotifyQueueTailLock**
Un processo è in attesa di aggiornare il limite sull’archiviazione dei messaggi di notifica.
**LWLockUn processo è in attesa sul buffer SLRU (simple least-recently used) per un messaggio NOTIFY. ----sep----:notifySLRU**
Un processo è in attesa di accedere alla cache semplice utilizzata meno di recente (SLRU) per un messaggio NOTIFY (NOTIFICA).
**LWLock:OidGen**
Un processo è in attesa di allocare un nuovo ID oggetto (OID).
**LWLock:OidGenLock**
Un processo è in attesa di allocare o assegnare un ID oggetto (OID).
**LWLock:notifySLRU ----sep----:oldserxid**
Un processo è in attesa su un buffer oldserxid I/O .
**LWLock:OldSerXidLock**
Un processo è in attesa di leggere o registrare transazioni serializzabili in conflitto.
**LWLock:OldSnapshotTimeMap**
Un processo è in attesa di leggere o aggiornare le informazioni meno recenti sul controllo degli snapshot.
**LWLock:OldSnapshotTimeMapLock**
Un processo è in attesa di leggere o aggiornare le informazioni meno recenti sul controllo degli snapshot.
**LWLockUn processo è in attesa su un buffer oldserxid. ----sep----:parallel\$1append**
Un processo è in attesa di scegliere il subplan successivo durante l'esecuzione parallela del piano di aggiunta.
**LWLock:parallel\$1append ----sep----:parallel\$1hash\$1join**
Un processo è in attesa di allocare o scambiare un blocco di memoria o di aggiornare i contatori durante l'esecuzione di un piano hash parallelo.
**LWLock:parallel\$1hash\$1join ----sep----:parallel\$1query\$1dsa**
Un processo è in attesa di un blocco sull'allocazione dinamica della memoria condivisa per una query parallela.
**LWLock:ParallelAppend**
Un processo è in attesa di scegliere il subplan successivo durante l'esecuzione parallela del piano di aggiunta.
**LWLock:ParallelHashJoin**
Un processo è in attesa di sincronizzare i lavori durante l'esecuzione del piano per un hash join parallelo.
**Lucchetto: DSA ParallelQuery**
Un processo è in attesa di un'allocazione dinamica della memoria condivisa per una query parallela.
**Lwlock: DSA PerSession**
Un processo è in attesa di un'allocazione dinamica della memoria condivisa per una query parallela.
**Serratura: PerSessionRecordType**
Un processo è in attesa di accedere alle informazioni di una query parallela sui tipi compositi.
**Serratura: PerSessionRecordTypmod**
Un processo è in attesa di accedere alle informazioni di una query parallela sui modificatori di tipo che identificano i tipi di record anonimi.
**Serratura: PerXactPredicateList**
Un processo è in attesa di accedere all'elenco dei blocchi del predicato tenuti dalla transazione serializzabile corrente durante una query parallela.
**Lwlock:predicate\$1lock\$1manager**
Un processo è in attesa di aggiungere o esaminare le informazioni sul blocco dei predicati.
**Serratura: PredicateLockManager**
Un processo è in attesa di accedere alle informazioni sul blocco predicato utilizzate dalle transazioni serializzabili.
**Lwlock:proc**
Un processo è in attesa di leggere o aggiornare le informazioni sul blocco del percorso rapido.
**LWLock:ProcArray**
Un processo è in attesa di accedere alle strutture dati condivise per processo (in genere, per ottenere uno snapshot o segnalare l'ID di transazione di una sessione).
**LWLock:ProcArrayLock**
Un processo è in attesa di ottenere uno snapshot o di cancellare un’ID di transazione alla fine di una transazione.
**LWLock:RelationMapping**
Un processo è in attesa di leggere o aggiornare un file `pg_filenode.map` (utilizzato monitorare le assegnazioni file-nodo di alcuni cataloghi di sistema).
**LWLock:RelationMappingLock**
Un processo è in attesa di aggiornare il file della mappa delle relazioni utilizzato per catalog-to-file-node memorizzare la mappatura.
**LWLock:RelCacheInit**
Un processo è in attesa di leggere o aggiornare un file `pg_internal.init` (un file di inizializzazione della cache delle relazioni).
**LWLock:RelCacheInitLock**
Un processo è in attesa di leggere o scrivere un file di inizializzazione della cache delle relazioni.
**LWLockUn processo è in attesa di aggiornare il file della mappa delle relazioni utilizzato per memorizzare la mappatura. ----sep----:replication\$1origin**
Un processo è in attesa di leggere o aggiornare l'avanzamento della replica.
**LWLock:replication\$1origin ----sep----:replication\$1slot\$1io**
Un processo è in attesa su uno slot di replica. I/O
**LWLock:ReplicationOrigin**
Un processo è in attesa di creare, eliminare o utilizzare un'origine di replica.
**LWLock:ReplicationOriginLock**
Un processo è in attesa di configurare, eliminare o utilizzare un'origine di replica.
**LWLock:ReplicationOriginState**
Un processo è in attesa di leggere o aggiornare l’avanzamento di un'origine di replica.
**LWLock:ReplicationSlotAllocation**
Un processo è in attesa di allocare o liberare uno slot di replica.
**LWLock:ReplicationSlotAllocationLock**
Un processo è in attesa di allocare o liberare uno slot di replica.
**LWLock:ReplicationSlotControl**
Un processo è in attesa di leggere o aggiornare lo stato di uno slot di replica.
**LWLock:ReplicationSlotControlLock**
Un processo è in attesa di leggere o aggiornare lo stato dello slot di replica.
**LWLock: IO ReplicationSlot**
Un processo è in attesa I/O su uno slot di replica.
**LWLock:SerialBuffer**
Un processo è in attesa di un conflitto di transazioni serializzabile I/O su un semplice buffer SLRU (Least-Recently Used).
**LWLock:SerializableFinishedList**
Un processo è in attesa di accedere all'elenco delle transazioni serializzabili finite.
**LWLock:SerializableFinishedListLock**
Un processo è in attesa di accedere all'elenco delle transazioni serializzabili finite.
**LWLock:SerializablePredicateList**
Un processo è in attesa di accedere all'elenco dei blocchi del predicato tenuti dalle transazioni serializzabili.
**LWLock:SerializablePredicateLockListLock**
Un processo è in attesa di eseguire un'operazione su un elenco di blocchi tenuti dalle transazioni serializzabili.
**LWLock:SerializableXactHash**
Un processo è in attesa di leggere o aggiornare le informazioni sulle transazioni serializzabili.
**LWLock:SerializableXactHashLock**
Un processo è in attesa di recuperare o archiviare informazioni sulle transazioni serializzabili.
**LWLockUn processo è in attesa su un semplice buffer SLRU (Least-Recently Used) per un conflitto di transazioni serializzabile. ----SEP----:SerialSLRU**
Un processo è in attesa di accedere alla cache semplice utilizzata meno di recente (SLRU) per un conflitto di transazioni serializzabile.
**LWLock:SharedTidBitmap**
Un processo è in attesa di accedere a una bitmap TID (shared tuple identifier) durante una scansione parallela dell'indice bitmap.
**LWLock:SharedTupleStore**
Un processo è in attesa di accedere a un archivio tupla condiviso durante una query parallela.
**LWLock:ShmemIndex**
Un processo è in attesa di trovare o allocare spazio nella memoria condivisa.
**LWLock:ShmemIndexLock**
Un processo è in attesa di trovare o allocare spazio nella memoria condivisa.
**LWLock: Leggi SInval**
Un processo è in attesa di recuperare i messaggi dalla coda di invalidamento del catalogo condiviso.
**LWLock:SInvalReadLock**
Un processo è in attesa di recuperare o rimuovere messaggi da una coda di invalidazione condivisa.
**LWLock: SInval Scrivi**
Un processo è in attesa di aggiungere un messaggio alla coda di invalidazione del catalogo condivisa.
**LWLock:SInvalWriteLock**
Un processo è in attesa di aggiungere un messaggio in una coda di invalidazione condivisa.
**LWLock:SyncRep**
Un processo è in attesa di leggere o aggiornare le informazioni sullo stato della replica sincrona.
**LWLock:SyncRepLock**
Un processo è in attesa di leggere o aggiornare le informazioni sulle repliche sincrone.
**LWLock:SyncScan**
Un processo è in attesa di selezionare la posizione iniziale di una scansione sincronizzata della tabella.
**LWLock:SyncScanLock**
Un processo è in attesa di ottenere la posizione iniziale di una scansione su una tabella per le scansioni sincronizzate.
**LWLock:TablespaceCreate**
Un processo è in attesa di creare o eliminare uno spazio tabella.
**LWLock:TablespaceCreateLock**
Un processo è in attesa di creare o eliminare uno spazio tabella.
**LWLock: Scrivi ----sep----:tbm**
Un processo è in attesa di un blocco iteratore condiviso su una bitmap ad albero (TBM).
**LWLock:TwoPhaseState**
Un processo è in attesa di leggere o aggiornare lo stato delle transazioni preparate.
**LWLock:TwoPhaseStateLock**
Un processo è in attesa di leggere o aggiornare lo stato delle transazioni preparate.
**LWLock:tbm ----sep----:wal\$1insert**
Un processo è in attesa di inserire il WAL (write-ahead log) in un buffer di memoria.
**LWLock: Mappatura WALBuf**
Un processo è in attesa di sostituire una pagina nei buffer WAL (write-ahead log).
**LWLock:WALBufMappingLock**
Un processo è in attesa di sostituire una pagina nei buffer WAL (write-ahead log).
**LWLock:WALInsert**
Un processo è in attesa di inserire i dati WAL (write-ahead log) in un buffer di memoria.
**LWLock:WALWrite**
Un processo è in attesa della scrittura dei buffer WAL (write-ahead log) su disco.
**LWLock: Serratura WALWrite**
Un processo è in attesa della scrittura dei buffer WAL (write-ahead log) su disco.
**LWLock:WrapLimitsVacuum**
Un processo è in attesa di aggiornare i limiti relativi all'ID di transazione e al consumo multixact.
**LWLock:WrapLimitsVacuumLock**
Un processo è in attesa di aggiornare i limiti relativi all'ID di transazione e al consumo multixact.
**LWLock:XactBuffer**
Un processo è in attesa dello stato della I/O transazione su un buffer SLRU (Simple Least-Recently Used).
**LWLockUn processo è in attesa su un semplice buffer SLRU (Least-Recently Used) per lo stato della transazione. ----sep----:xACTSLRU**
Un processo è in attesa di accedere alla cache semplice utilizzata meno di recente (SLRU) per lo stato di una transazione.
**LWLock:XactTruncation**
Un processo è in attesa di eseguire pg\$1xact\$1status o di aggiornare l'ID di transazione meno recente disponibile.
**LWLock:XidGen**
Un processo è in attesa di allocare un nuovo ID di transazione.
**LWLock:XidGenLock**
Un processo è in attesa di allocare o assegnare un ID di transazione.
**Timeout: BaseBackupThrottle**
Un processo è in attesa durante il backup di base quando si limita l'attività.
**Tempo scaduto: PgSleep**
Un processo di backend ha chiamato la funzione pg\$1sleep ed è in attesa della scadenza del timeout di riposo. Per ulteriori informazioni, consulta [Timeout: PG Sleep](apg-waits.timeoutpgsleep.md).
**Tempo scaduto: RecoveryApplyDelay**
Un processo è in attesa di applicare il WAL (write-ahead log) durante il ripristino a causa di un'impostazione di ritardo.
**Tempo scaduto: RecoveryRetrieveRetryInterval**
Un processo è in attesa durante il ripristino quando i dati WAL (write-ahead log) non sono disponibili da nessuna fonte (pg\$1wal, archivio o flusso).
**Tempo scaduto: VacuumDelay**
Un processo è in attesa in un punto di ritardo del vacuum basato sui costi.
Per un elenco completo degli eventi di attesa PostgreSQL, consulta la pagina relativa al [processo di raccolta delle statistiche e alle tabelle degli eventi di attesa](https://www.postgresql.org/docs/current/monitoring-stats.html#WAIT-EVENT-TABLE) nella documentazione di PostgreSQL.