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à. # Funzioni di Aurora PostgreSQL Limitless Database La tabella seguente mostra le nuove funzioni per Aurora PostgreSQL Limitless Database. **Nota** Le funzioni elencate in questa tabella si trovano nello schema `rds_aurora`. Quando utilizzi una funzione di Limitless Database, assicurati di includere il nome completo dell’oggetto: `rds_aurora`.`object_name`. | Funzione di Aurora PostgreSQL Limitless Database | Funzione di Aurora PostgreSQL corrispondente | | --- | --- | | [limitless\$1backend\$1dsid](#limitless_backend_dsid) | pg\$1backend\$1pid | | [limitless\$1cancel\$1session](#limitless_cancel_session) | pg\$1cancel\$1backend | | [limitless\$1stat\$1clear\$1snapshot](#limitless_stat_clear_snapshot) | pg\$1stat\$1clear\$1snapshot | | [limitless\$1stat\$1database\$1size](#limitless_stat_database_size) | pg\$1database\$1size | | [limitless\$1stat\$1get\$1snapshot\$1timestamp](#limitless_stat_get_snapshot_timestamp) | pg\$1stat\$1get\$1snapshot\$1timestamp | | [limitless\$1stat\$1prepared\$1xacts](#limitless_stat_prepared_xacts) | pg\$1prepared\$1xacts | | [limitless\$1stat\$1relation\$1sizes](#limitless_stat_relation_sizes) | pg\$1indexes\$1size, pg\$1relation\$1size, pg\$1table\$1size, pg\$1total\$1relation\$1size | | [limitless\$1stat\$1reset](#limitless_stat_reset) | pg\$1stat\$1reset | | [limitless\$1stat\$1statements\$1reset](#limitless_stat_statements_reset) | pg\$1stat\$1statements\$1reset | | [limitless\$1stat\$1system\$1waits](#limitless_stat_system_waits) | aurora\$1stat\$1system\$1waits | | [limitless\$1terminate\$1session](#limitless_terminate_session) | pg\$1terminate\$1backend | | [limitless\$1wait\$1report](#limitless_wait_report) | aurora\$1wait\$1report | Gli esempi seguenti forniscono dettagli sulle funzioni di Aurora PostgreSQL Limitless Database. Per ulteriori informazioni sulle funzioni di PostgreSQL, consulta [Functions and operators](https://www.postgresql.org/docs/15/functions.html) nella documentazione di PostgreSQL. **limitless\$1backend\$1dsid** La funzione `limitless_backend_dsid` restituisce l’ID di sessione distribuita per la sessione corrente. Una sessione distribuita viene eseguita su un router in un gruppo di shard del database e coinvolge processi di backend su uno o più shard del gruppo di shard del database. Il seguente esempio illustra come utilizzare la funzione `limitless_backend_dsid`. ``` SELECT rds_aurora.limitless_backend_dsid(); limitless_backend_dsid ------------------------ 8CACD7B04D0FC2A5 (1 row) ``` **limitless\$1cancel\$1session** La funzione `limitless_cancel_session` funziona in modo simile a `pg_cancel_backend`, ma tenta di annullare tutti i processi di backend associati all’ID di sessione distribuita fornito, inviando un `SIGINT` (segnale di interruzione). Il parametro di input è il seguente: + `distributed_session_id` (testo): l’ID della sessione distribuita da annullare. I parametri di output sono i seguenti: + `subcluster_id` (testo): l’ID del cluster secondario a cui appartiene il processo. + `pid` (testo): l’ID del processo di backend. + `success` (booleano): indica se l’annullamento è riuscito. Il seguente esempio illustra come utilizzare la funzione `limitless_cancel_session`. ``` SELECT * FROM rds_aurora.limitless_cancel_session('940CD5C81E3C796B'); subcluster_id | pid | success ---------------+-------+--------- 1 | 26920 | t (1 row) ``` **limitless\$1stat\$1clear\$1snapshot** La funzione `limitless_stat_clear_snapshot` elimina lo snapshot delle statistiche corrente o le informazioni memorizzate nella cache su tutti i nodi. Il seguente esempio illustra come utilizzare la funzione `limitless_stat_clear_snapshot`. ``` SELECT rds_aurora.limitless_stat_clear_snapshot(); ``` **limitless\$1stat\$1database\$1size** La funzione `limitless_stat_database_size` restituisce le dimensioni di un database nel gruppo di shard del database. Il parametro di input è il seguente: + `dbname` (nome): il database per il quale ottenere le dimensioni. I parametri di output sono i seguenti: + `subcluster_id` (testo): l’ID del cluster secondario a cui appartiene il processo. + `subcluster_type` (testo): il tipo di cluster secondario a cui appartiene questo processo (`router` o `shard`). + `db_size`: la dimensione del database in questo cluster secondario in byte. Il seguente esempio illustra come utilizzare la funzione `limitless_stat_database_size`. ``` SELECT * FROM rds_aurora.limitless_stat_database_size('postgres_limitless'); subcluster_id | subcluster_type | db_size ---------------+-----------------+---------- 1 | router | 8895919 2 | router | 8904111 3 | shard | 21929391 4 | shard | 21913007 5 | shard | 21831087 (5 rows) ``` **limitless\$1stat\$1get\$1snapshot\$1timestamp** La funzione `limitless_stat_get_snapshot_timestamp` restituisce il timestamp dello snapshot delle statistiche corrente oppure `NULL` se non è stato acquisito alcuno snapshot. Uno snapshot viene acquisito al primo accesso alle statistiche cumulative in una transazione, se `stats_fetch_consistency` è impostato su `snapshot`. Restituisce una visualizzazione consolidata dei timestamp degli snapshot da tutti i nodi. Le colonne `subcluster_id` e `subcluster_type` mostrano da quale nodo provengono i dati. Il seguente esempio illustra come utilizzare la funzione `limitless_stat_get_snapshot_timestamp`. ``` SELECT * FROM rds_aurora.limitless_stat_get_snapshot_timestamp(); subcluster_id | subcluster_type | snapshot_timestamp ---------------+-----------------+-------------------- 1 | router | 2 | router | 3 | shard | 4 | shard | 5 | shard | (5 rows) ``` **limitless\$1stat\$1prepared\$1xacts** La funzione `limitless_stat_prepared_xacts` restituisce informazioni sulle transazioni su tutti i nodi attualmente preparati per il commit in due fasi. Per ulteriori informazioni, consulta [pg\$1prepared\$1xacts](https://www.postgresql.org/docs/current/view-pg-prepared-xacts.html) nella documentazione di PostgreSQL. Il seguente esempio illustra come utilizzare la funzione `limitless_stat_prepared_xacts`. ``` postgres_limitless=> SELECT * FROM rds_aurora.limitless_stat_prepared_xacts; subcluster_id | subcluster_type | transaction_id | gid | prepared | owner_id | database_id ---------------+-----------------+----------------+------------------------------+-------------------------------+------------+-------------------- 8 | shard | 5815978 | 7_4599899_postgres_limitless | 2024-09-03 15:51:17.659603+00 | auroraperf | postgres_limitless 12 | shard | 4599138 | 7_4599899_postgres_limitless | 2024-09-03 15:51:17.659637+00 | auroraperf | postgres_limitless (2 rows) ``` **limitless\$1stat\$1relation\$1sizes** La funzione `limitless_stat_relation_sizes` restituisce le diverse dimensioni di una tabella nel gruppo di shard del database. I parametri di input sono i seguenti: + `relnspname` (nome): il nome dello schema contenente la tabella. + `relname` (nome): il nome della tabella. I parametri di output sono i seguenti: + `subcluster_id` (testo): l’ID del cluster secondario a cui appartiene il processo. + `subcluster_type` (testo): il tipo di cluster secondario a cui appartiene questo processo (`router` o `shard`). + `main_size`: la dimensione in byte della fork dei dati principale in questo nodo. + `fsm_size`: la dimensione in byte della mappa dello spazio libero per la tabella in questo nodo. + `vm_size`: la dimensione in byte della mappa di visibilità per la tabella in questo nodo. + `init_size`: la dimensione in byte dell’inizializzazione della tabella in questo nodo. + `toast_size`: la dimensione in byte della tabella TOAST associata alla tabella in questa forcella. + `index_size`: la dimensione in byte di tutti gli indici della tabella in questo nodo. + `total_size`: la dimensione in byte di tutti i segmenti della tabella in questo nodo. Il seguente esempio illustra come utilizzare la funzione `limitless_stat_relation_sizes` (alcune colonne sono omesse). ``` SELECT * FROM rds_aurora.limitless_stat_relation_sizes('public','customers'); subcluster_id | subcluster_type | main_size | fsm_size | vm_size | toast_size | table_size | total_size ---------------+-----------------+-----------+----------+---------+------------+------------+------------ 1 | router | 0 | 0 | 0 | 0 | 0 | 0 2 | router | 0 | 0 | 0 | 0 | 0 | 0 3 | shard | 4169728 | 4177920 | 1392640 | 1392640 | 11132928 | 11132928 4 | shard | 4169728 | 4177920 | 1392640 | 1392640 | 11132928 | 11132928 5 | shard | 3981312 | 4227072 | 1409024 | 1409024 | 11026432 | 11026432 (5 rows) ``` **limitless\$1stat\$1reset** La funzione `limitless_stat_reset` azzera tutti i contatori delle statistiche per il database corrente impostandoli su zero (0). Se `track_functions` è abilitato, la colonna `stats_reset` in `limitless_stat_database` mostra l’ultima volta in cui le statistiche sono state reimpostate per il database. Per impostazione predefinita, `limitless_stat_reset` può essere eseguito solo da un utente con privilegi avanzati. È possibile concedere l’autorizzazione ad altri utenti utilizzando il privilegio `EXECUTE`. Il seguente esempio illustra come utilizzare la funzione `limitless_stat_reset`. ``` SELECT tup_inserted, tup_deleted FROM pg_stat_database WHERE datname = 'postgres_limitless'; tup_inserted | tup_deleted --------------+------------- 896 | 0 (1 row) SELECT rds_aurora.limitless_stat_reset(); limitless_stat_reset --------------------- (1 row) SELECT tup_inserted, tup_deleted FROM pg_stat_database WHERE datname = 'postgres_limitless'; tup_inserted | tup_deleted -------------+------------- 0 | 0 (1 row) ``` **limitless\$1stat\$1statements\$1reset** La funzione `limitless_stat_statements_reset` elimina le statistiche raccolte finora da `limitless_stat_statements` corrispondenti ai parametri `username`, `dbname`, `distributed_query_id` e `queryid` specificati. Se uno qualsiasi dei parametri non è specificato, viene utilizzato il valore predefinito `""` o `0` (non valido) per ciascuno di essi e vengono reimpostate le statistiche che corrispondono agli altri parametri. Se nessun parametro viene specificato o tutti i parametri specificati sono `""` o `0` (non valido), la funzione elimina tutte le statistiche. Se tutte le statistiche nella visualizzazione `limitless_stat_statements` vengono eliminate, la funzione reimposta anche le statistiche nella visualizzazione `limitless_stat_statements_info`. I parametri di input sono i seguenti: + `username` (nome): l’utente che ha eseguito la query sull’istruzione. + `dbname` (nome): il database su cui è stata eseguita la query. + `distributed_query_id` (bigint): l’ID della query principale proveniente dal nodo coordinatore. Questa colonna è `NULL` se è la query principale. Il nodo coordinatore esegue il push down dell’ID della query distribuita ai nodi partecipanti. Pertanto, per i nodi partecipanti, i valori dell’ID della query distribuita e dell’ID della query principale sono diversi. + `queryid` (bigint): l’ID della query dell’istruzione. Il seguente esempio illustra come utilizzare la funzione `limitless_stat_statements_reset` per reimpostare tutte le statistiche raccolte da `limitless_stat_statements`. ``` SELECT rds_aurora.limitless_stat_statements_reset(); ``` **limitless\$1stat\$1system\$1waits** La funzione `limitless_stat_system_waits` restituisce una visualizzazione consolidata dei dati degli eventi di attesa da `aurora_stat_system_waits`, che riporta l’attività di attesa a livello di sistema in un’istanza, da tutti i nodi. Le colonne `subcluster_id` e `subcluster_type` mostrano da quale nodo provengono i dati. Il seguente esempio illustra come utilizzare la funzione `limitless_stat_system_waits`. ``` postgres_limitless=> SELECT * FROM rds_aurora.limitless_stat_system_waits() lssw, pg_catalog.aurora_stat_wait_event() aswe WHERE lssw.event_id=aswe.event_id and aswe.event_name='LimitlessTaskScheduler'; subcluster_id | subcluster_type | type_id | event_id | waits | wait_time | event_name ---------------+-----------------+---------+-----------+--------+--------------+------------------------ 1 | router | 12 | 201326607 | 677068 | 616942216307 | LimitlessTaskScheduler 2 | router | 12 | 201326607 | 678586 | 616939897111 | LimitlessTaskScheduler 3 | shard | 12 | 201326607 | 756640 | 616965545172 | LimitlessTaskScheduler 4 | shard | 12 | 201326607 | 755184 | 616958057620 | LimitlessTaskScheduler 5 | shard | 12 | 201326607 | 757522 | 616963183539 | LimitlessTaskScheduler (5 rows) ``` **limitless\$1terminate\$1session** La funzione `limitless_terminate_session` funziona in modo simile a `pg_terminate_backend`, ma tenta di terminare tutti i processi di backend associati all’ID di sessione distribuita fornito, inviando un `SIGTERM` (segnale di termine). Il parametro di input è il seguente: + `distributed_session_id` (testo): l’ID della sessione distribuita da terminare. I parametri di output sono i seguenti: + `subcluster_id` (testo): l’ID del cluster secondario a cui appartiene il processo. + `pid` (testo): l’ID del processo di backend. + `success` (booleano): indica se il processo è stato terminato correttamente. Il seguente esempio illustra come utilizzare la funzione `limitless_terminate_session`. ``` SELECT * FROM rds_aurora.limitless_terminate_session('940CD5C81E3C796B'); subcluster_id | pid | success ---------------+-------+--------- 1 | 26920 | t (1 row) ``` **limitless\$1wait\$1report** La funzione `limitless_wait_report` restituisce l’attività degli eventi di attesa di tutti i nodi in un periodo di tempo. Le colonne `subcluster_id` e `subcluster_type` mostrano da quale nodo provengono i dati. I parametri di output sono i seguenti: + `subcluster_id` (testo): l’ID del cluster secondario a cui appartiene il processo. + `subcluster_type` (testo): il tipo di cluster secondario a cui appartiene questo processo (`router` o `shard`). Le restanti colonne sono le stesse di `aurora_wait_report`. Il seguente esempio illustra come utilizzare la funzione `limitless_wait_report`. ``` postgres_limitless=> select * from rds_aurora.limitless_wait_report(); subcluster_id | subcluster_type | type_name | event_name | waits | wait_time | ms_per_wait | waits_per_xact | ms_per_xact ---------------+-----------------+-----------+------------+-------+-----------+-------------+--------------- +------------- 1 | router | Client | ClientRead | 57 | 741550.14 | 13009.652 | 0.19 | 2505.237 5 | shard | Client | ClientRead | 54 | 738897.68 | 13683.290 | 0.18 | 2496.276 4 | shard | Client | ClientRead | 54 | 738859.53 | 13682.584 | 0.18 | 2496.147 2 | router | Client | ClientRead | 53 | 719223.64 | 13570.257 | 0.18 | 2429.810 3 | shard | Client | ClientRead | 54 | 461720.40 | 8550.378 | 0.18 | 1559.86 ```