# Funções do Aurora PostgreSQL Limitless Database A tabela a seguir mostra as novas funções do Aurora PostgreSQL Limitless Database. **nota** As funções listadas nesta tabela estão localizadas no esquema `rds_aurora`. Ao usar uma função do Limitless Database, inclua o nome do objeto totalmente qualificado: `rds_aurora`.`object_name`. | Função do Aurora PostgreSQL Limitless Database | Função correspondente do Aurora PostgreSQL | | --- | --- | | [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 | Os exemplos a seguir fornecem detalhes sobre as funções do Aurora PostgreSQL Limitless Database. Para obter mais informações sobre funções do PostgreSQL, consulte [Functions and operators](https://www.postgresql.org/docs/15/functions.html) na documentação do PostgreSQL. **limitless\$1backend\$1dsid** A função `limitless_backend_dsid` retorna o ID da sessão distribuída para a sessão atual. Uma sessão distribuída é executada em um roteador em um grupo de fragmentos de banco de dados e envolve processos de backend em um ou mais fragmentos no grupo de fragmentos de banco de dados. O exemplo a seguir mostra como usar a função `limitless_backend_dsid`. ``` SELECT rds_aurora.limitless_backend_dsid(); limitless_backend_dsid ------------------------ 8CACD7B04D0FC2A5 (1 row) ``` **limitless\$1cancel\$1session** A função `limitless_cancel_session` funciona de forma semelhante a `pg_cancel_backend`, mas tenta cancelar todos os processos de backend relacionados ao ID de sessão distribuído fornecido enviando um `SIGINT` (sinal de interrupção). O parâmetro de entrada é o seguinte: + `distributed_session_id` (texto): o ID da sessão distribuída a ser cancelada. Os parâmetros de saída são os seguintes: + `subcluster_id` (texto): o ID do subcluster ao qual esse processo pertence. + `pid` (texto): o ID do processo de backend. + `success` (booleano): se o cancelamento foi bem-sucedido. O exemplo a seguir mostra como usar a função `limitless_cancel_session`. ``` SELECT * FROM rds_aurora.limitless_cancel_session('940CD5C81E3C796B'); subcluster_id | pid | success ---------------+-------+--------- 1 | 26920 | t (1 row) ``` **limitless\$1stat\$1clear\$1snapshot** A função `limitless_stat_clear_snapshot` descarta o snapshot das estatísticas atuais ou as informações em cache em todos os nós. O exemplo a seguir mostra como usar a função `limitless_stat_clear_snapshot`. ``` SELECT rds_aurora.limitless_stat_clear_snapshot(); ``` **limitless\$1stat\$1database\$1size** A função `limitless_stat_database_size` retorna os tamanhos de um banco de dados no grupo de fragmentos de banco de dados. O parâmetro de entrada é o seguinte: + `dbname` (nome): o banco de dados para o qual obter os tamanhos. Os parâmetros de saída são os seguintes: + `subcluster_id` (texto): o ID do subcluster ao qual esse processo pertence. + `subcluster_type` (texto): o tipo de subcluster ao qual esse processo pertence: `router` ou `shard`. + `db_size`: o tamanho do banco de dados nesse subcluster em bytes. O exemplo a seguir mostra como usar a função `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** A função `limitless_stat_get_snapshot_timestamp` retorna a data e hora do snapshot de estatísticas atual ou `NULL` se nenhum instantâneo de estatísticas foi obtido. Um snapshot é obtido na primeira vez que as estatísticas cumulativas são acessadas em uma transação, se `stats_fetch_consistency` estiver definido como `snapshot`. Retorna uma visão consolidada dos registros de data e hora dos snapshots de todos os nós. As colunas `subcluster_id` e `subcluster_type` mostram de qual nó os dados são provenientes. O exemplo a seguir mostra como usar a função `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** A função `limitless_stat_prepared_xacts` retorna informações sobre transações em todos os nós que estão atualmente preparados para a confirmação em duas fases. Para obter mais informações, consulte [pg\$1prepared\$1xacts](https://www.postgresql.org/docs/current/view-pg-prepared-xacts.html) na documentação do PostgreSQL. O exemplo a seguir mostra como usar a função `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** A função `limitless_stat_relation_sizes` retorna os diferentes tamanhos de uma tabela no grupo de fragmentos de banco de dados. Os parâmetros de entrada são os seguintes: + `relnspname` (nome): o nome do esquema que contém a tabela. + `relname` (nome): o nome da tabela. Os parâmetros de saída são os seguintes: + `subcluster_id` (texto): o ID do subcluster ao qual esse processo pertence. + `subcluster_type` (texto): o tipo de subcluster ao qual esse processo pertence: `router` ou `shard`. + `main_size`: o tamanho em bytes da bifurcação de dados principal nesse nó. + `fsm_size`: o tamanho em bytes do mapa de espaço livre da tabela nesse nó. + `vm_size`: o tamanho em bytes do mapa de visibilidade da tabela nesse nó. + `init_size`: o tamanho em bytes da inicialização da tabela nesse nó. + `toast_size`: o tamanho em bytes da tabela toast associada à tabela nessa bifurcação. + `index_size`: o tamanho em bytes de todos os índices da tabela nesse nó. + `total_size`: o tamanho em bytes de todos os segmentos da tabela nesse nó. O exemplo a seguir mostra como usar a função `limitless_stat_relation_sizes` (algumas colunas são omitidas). ``` 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** A função `limitless_stat_reset` redefine todos os contadores de estatísticas do banco de dados atual para zero (0). Se `track_functions` estiver habilitado, a coluna `stats_reset` em `limitless_stat_database` mostrará a última vez em que as estatísticas foram redefinidas para o banco de dados. Por padrão, `limitless_stat_reset` pode ser executado apenas por um superusuário. Outros usuários podem receber permissão usando o privilégio `EXECUTE`. O exemplo a seguir mostra como usar a função `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** A função `limitless_stat_statements_reset` descarta as estatísticas coletadas até o momento por `limitless_stat_statements` correspondentes aos parâmetros `username`, `dbname`, `distributed_query_id` e `queryid` especificados. Se algum dos parâmetros não for especificado, o valor padrão `""` ou `0` (inválido) será usado para cada um deles e as estatísticas que corresponderem a outros parâmetros serão redefinidas. Se nenhum parâmetro for especificado, ou se todos os parâmetros especificados forem `""` ou `0` (inválidos), a função descartará todas as estatísticas. Se todas as estatísticas na visualização `limitless_stat_statements` forem descartadas, a função também redefinirá as estatísticas na visualização `limitless_stat_statements_info`. Os parâmetros de entrada são os seguintes: + `username` (nome): o usuário que consultou a instrução. + `dbname` (nome): o banco de dados onde a consulta foi executada. + `distributed_query_id` (bigint): o ID da consulta principal do nó coordenador. Essa coluna é `NULL` se for a consulta principal. O nó coordenador envia o ID da consulta distribuída para os nós participantes. Portanto, para os nós participantes, os valores para o ID de consulta distribuída e o ID de consulta são diferentes. + `queryid` (bigint): o ID de consulta da instrução. O exemplo a seguir mostra como usar a função `limitless_stat_statements_reset` para redefinir todas as estatísticas coletadas pelo `limitless_stat_statements`. ``` SELECT rds_aurora.limitless_stat_statements_reset(); ``` **limitless\$1stat\$1system\$1waits** A função `limitless_stat_system_waits` retorna uma visão consolidada dos dados do evento de espera de `aurora_stat_system_waits`, que relata a atividade de espera em todo o sistema em uma instância, de todos os nós. As colunas `subcluster_id` e `subcluster_type` mostram de qual nó os dados são provenientes. O exemplo a seguir mostra como usar a função `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** A função `limitless_terminate_session` funciona de forma semelhante a `pg_terminate_backend`, mas tenta encerrar todos os processos de backend relacionados ao ID de sessão distribuído fornecido enviando um `SIGTERM` (sinal de término). O parâmetro de entrada é o seguinte: + `distributed_session_id` (texto): o ID da sessão distribuída a ser encerrada. Os parâmetros de saída são os seguintes: + `subcluster_id` (texto): o ID do subcluster ao qual esse processo pertence. + `pid` (texto): o ID do processo de backend. + `success` (booleano): se o processo foi encerrado com sucesso. O exemplo a seguir mostra como usar a função `limitless_terminate_session`. ``` SELECT * FROM rds_aurora.limitless_terminate_session('940CD5C81E3C796B'); subcluster_id | pid | success ---------------+-------+--------- 1 | 26920 | t (1 row) ``` **limitless\$1wait\$1report** A função `limitless_wait_report` retorna a atividade de eventos de espera por um período de todos os nós. As colunas `subcluster_id` e `subcluster_type` mostram de qual nó os dados são provenientes. Os parâmetros de saída são os seguintes: + `subcluster_id` (texto): o ID do subcluster ao qual esse processo pertence. + `subcluster_type` (texto): o tipo de subcluster ao qual esse processo pertence: `router` ou `shard`. As demais colunas são as mesmas que em `aurora_wait_report`. O exemplo a seguir mostra como usar a função `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 ```