# Funções e visualizações do Aurora PostgreSQL Limitless Database
O Aurora PostgreSQL Limitless Database adicionou funções e visualizações. Elas são baseadas nas funções e visualizações correspondentes do Aurora PostgreSQL.
**nota**
Algumas estatísticas podem retornar resultados inconsistentes se houver transações em andamento.
**Topics**
+ [Funções do Aurora PostgreSQL Limitless Database](limitless-monitoring-functions.md)
+ [Visualizações do Aurora PostgreSQL Limitless Database](limitless-monitoring-views.md)
# 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
```
# Visualizações do Aurora PostgreSQL Limitless Database
A tabela a seguir mostra as novas visualizações do Aurora PostgreSQL Limitless Database.
**nota**
As visualizações listadas nessa tabela estão localizadas no esquema `rds_aurora`. Ao usar uma visualização do Limitless Database, inclua o nome do objeto totalmente qualificado: `rds_aurora`.`object_name`.
| Visualização do Aurora PostgreSQL Limitless Database | Visualização correspondente do Aurora PostgreSQL |
| --- | --- |
| [limitless\$1database](#limitless_database) | pg\$1database |
| [limitless\$1locks](#limitless_locks) | pg\$1locks |
| [limitless\$1stat\$1activity](#limitless_stat_activity) | pg\$1stat\$1activity |
| [limitless\$1stat\$1all\$1indexes](#limitless_stat_all_indexes) | pg\$1stat\$1all\$1indexes |
| [limitless\$1stat\$1all\$1tables](#limitless_stat_all_tables) | pg\$1stat\$1all\$1tables |
| [limitless\$1stat\$1database](#limitless_stat_database) | pg\$1stat\$1database |
| [limitless\$1stat\$1progress\$1vacuum](#limitless_stat_progress_vacuum) | pg\$1stat\$1progress\$1vacuum |
| [limitless\$1stat\$1statements](#limitless_stat_statements) | pg\$1stat\$1statements |
| [limitless\$1stat\$1subclusters](#limitless_stat_subclusters) | Nenhum |
| [limitless\$1stat\$1statements\$1info](#limitless_stat_statements_info) | pg\$1stat\$1statements\$1info |
| [limitless\$1statio\$1all\$1indexes](#limitless_statio_all_indexes) | pg\$1statio\$1all\$1indexes |
| [limitless\$1statio\$1all\$1tables](#limitless_statio_all_tables) | pg\$1statio\$1all\$1tables |
| [limitless\$1tables](#limitless_tables) | pg\$1tables |
| [limitless\$1table\$1collocations](#limitless_table_collocations) | Nenhum |
| [limitless\$1table\$1collocation\$1distributions](#limitless_table_collocation_distributions) | Nenhum |
Os exemplos a seguir fornecem detalhes sobre as visualizações do Aurora PostgreSQL Limitless Database. Para obter mais informações sobre visualizações do PostgreSQL, consulte [Viewing statistics](https://www.postgresql.org/docs/15/monitoring-stats.html#MONITORING-STATS-VIEWS) na documentação do PostgreSQL.
**nota**
Algumas visualizações de estatísticas podem retornar resultados inconsistentes se você tiver transações em andamento.
**limitless\$1database**
Essa visualização contém informações sobre os bancos de dados disponíveis no grupo de fragmentos de banco de dados. Por exemplo:
```
postgres_limitless=> SELECT subcluster_id, subcluster_type, oid, datname, datacl FROM rds_aurora.limitless_database;
subcluster_id | subcluster_type | oid | datname | datacl
---------------+-----------------+-------+--------------------+------------------------------------------------------------------------------------------------------------------------
2 | router | 4 | template0 | {=c/rdsadmin,rdsadmin=CTc/rdsadmin}
2 | router | 5 | postgres |
2 | router | 16384 | rdsadmin | {rdsadmin=CTc/rdsadmin,rds_aurora_limitless_metadata_admin=c/rdsadmin,rds_aurora_limitless_heat_mgmt_admin=c/rdsadmin}
2 | router | 16477 | postgres_limitless |
2 | router | 1 | template1 | {=c/rdsadmin,rdsadmin=CTc/rdsadmin}
6 | shard | 4 | template0 | {=c/rdsadmin,rdsadmin=CTc/rdsadmin}
```
Os parâmetros de saída são os seguintes:
+ `subcluster_id` (texto): o ID do subcluster (nó)
+ `subcluster_type` (texto): o tipo de subcluster (nó), roteador ou fragmento
As demais colunas são as mesmas que em `pg_database`.
**limitless\$1locks**
Essa visualização contém uma linha por processo por nó. Ela fornece acesso às informações sobre os bloqueios mantidos pelos processos ativos no servidor do banco de dados.
**Example de criação de um bloqueio com duas transações**
Neste exemplo, executamos duas transações simultaneamente em dois roteadores.
```
# Transaction 1 (run on router 1)
BEGIN;
SET search_path = public;
SELECT * FROM customers;
INSERT INTO customers VALUES (400,'foo','bar');
# Transaction 2 (run on router 2)
BEGIN;
SET search_path = public;
ALTER TABLE customers ADD COLUMN phone VARCHAR;
```
A primeira transação é executada. As transações subsequentes precisam esperar até que a primeira transação seja concluída. Portanto, a segunda transação é bloqueada com um bloqueio. Para verificar a causa raiz disso, executamos um comando unindo `limitless_locks` com `limitless_stat_activity`.
```
# Run on router 2
SELECT distributed_session_id, state, usename, query, query_start
FROM rds_aurora.limitless_stat_activity
WHERE distributed_session_id in (
SELECT distributed_session_id
FROM rds_aurora.limitless_locks
WHERE relname = 'customers'
);
distributed_session_id | state | usename | query | query_start
------------------------+---------------------+--------------------------+---------------------------------- -------------+-------------------------------
47BDE66E9A5E8477 | idle in transaction | limitless_metadata_admin | INSERT INTO customers VALUES (400,'foo','bar'); | 2023-04-13 17:44:45.152244+00
2AD7F370202D0FA9 | active | limitless_metadata_admin | ALTER TABLE customers ADD COLUMN phone VARCHAR; | 2023-04-13 17:44:55.113388+00
47BDE66E9A5E8477 | | limitless_auth_admin | |
2AD7F370202D0FA9 | | limitless_auth_admin | |
47BDE66E9A5E8477 | | limitless_auth_admin | |
2AD7F370202D0FA9 | | limitless_auth_admin | |
(6 rows)
```
**Example de criação de um bloqueio de forma explícita**
Neste exemplo, criamos um bloqueio explicitamente e, em seguida, usamos a visualização `limitless_locks` para ver os bloqueios (algumas colunas são omitidas).
```
BEGIN;
SET search_path = public;
LOCK TABLE customers IN ACCESS SHARE MODE;
SELECT * FROM rds_aurora.limitless_locks WHERE relname = 'customers';
subcluster_id | subcluster_type | distributed_session_id | locktype | datname | relnspname | relname | virtualtransaction | pid | mode
---------------+-----------------+------------------------+----------+--------------------+------------+ ----------+--------------------+-------+-----------------
1 | router | 7207702F862FC937 | relation | postgres_limitless | public | customers | 28/600787 | 59564 | AccessShareLock
2 | router | 7207702F862FC937 | relation | postgres_limitless | public | customers | 28/600405 | 67130 | AccessShareLock
3 | shard | 7207702F862FC937 | relation | postgres_limitless | public | customers | 15/473401 | 27735 | AccessShareLock
4 | shard | 7207702F862FC937 | relation | postgres_limitless | public | customers | 13/473524 | 27734 | AccessShareLock
5 | shard | 7207702F862FC937 | relation | postgres_limitless | public | customers | 13/472935 | 27737 | AccessShareLock
6 | shard | 7207702F862FC937 | relation | postgres_limitless | public | customers | 13/473015 | 48660 | AccessShareLock
(6 rows)
```
**limitless\$1stat\$1activity**
Essa visualização contém uma linha por processo por nó. Ela pode ser usada para monitorar a integridade geral do sistema e triar processos que estão demorando muito. Por exemplo:
```
postgres=# SELECT
subcluster_id,
subcluster_type,
distributed_session_id,
distributed_session_state,
datname,
distributed_query_id,
is_sso_query
FROM
rds_aurora.limitless_stat_activity
WHERE
distributed_session_id in ('D2470C97E3D07E06', '5A3CD7B8E5FD13FF')
order by distributed_session_id;
subcluster_id | subcluster_type | distributed_session_id | distributed_session_state | datname | distributed_query_id | is_sso_query
---------------+-----------------+------------------------+---------------------------+--------------------+----------------------+--------------
2 | router | 5A3CD7B8E5FD13FF | coordinator | postgres_limitless | | f
3 | shard | 5A3CD7B8E5FD13FF | participant | postgres_limitless | 6808291725541680947 |
4 | shard | 5A3CD7B8E5FD13FF | participant | postgres_limitless | 6808291725541680947 |
2 | router | D2470C97E3D07E06 | coordinator | postgres_limitless | | t
3 | shard | D2470C97E3D07E06 | participant | postgres_limitless | 4058400544464210222 |
(5 rows)
```
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`.
+ `distributed_session_id` (texto): o ID da sessão distribuída à qual esse processo pertence.
+ `distributed_session_state` (texto): se este é um coordenador, participante ou processo autônomo/não distribuído (mostrado como `NULL`).
+ `datname` (texto): o banco de dados ao qual esse processo está conectado.
+ `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.
+ `is_sso_query` (texto) — isso nos permite saber se a consulta está otimizada para um único fragmento ou não.
As demais colunas são as mesmas que em `pg_stat_activity`.
**limitless\$1stat\$1all\$1indexes**
Essa visualização contém estatísticas de uso em índices no grupo de fragmentos de banco de dados. Por exemplo:
```
postgres_limitless=> SELECT schemaname, relname, indexrelname, idx_scan
FROM rds_aurora.limitless_stat_all_indexes
WHERE relname LIKE 'orders_ts%' ORDER BY indexrelname LIMIT 10;
schemaname | relname | indexrelname | idx_scan
------------+----------------+---------------------+----------
ec_sample | orders_ts00001 | orders_ts00001_pkey | 196801
ec_sample | orders_ts00002 | orders_ts00002_pkey | 196703
ec_sample | orders_ts00003 | orders_ts00003_pkey | 196376
ec_sample | orders_ts00004 | orders_ts00004_pkey | 197966
ec_sample | orders_ts00005 | orders_ts00005_pkey | 195301
ec_sample | orders_ts00006 | orders_ts00006_pkey | 195673
ec_sample | orders_ts00007 | orders_ts00007_pkey | 194475
ec_sample | orders_ts00008 | orders_ts00008_pkey | 191694
ec_sample | orders_ts00009 | orders_ts00009_pkey | 193744
ec_sample | orders_ts00010 | orders_ts00010_pkey | 195421
(10 rows)
```
**limitless\$1stat\$1all\$1tables**
Essa visualização contém estatísticas sobre todas as tabelas no banco de dados atual no grupo de fragmentos de banco de dados. Isso é útil ao rastrear operações de limpeza e operações de Linguagem de Manipulação de Dados (DML). Por exemplo:
```
postgres_limitless=> SELECT subcluster_id, subcluster_type, relname, n_ins_since_vacuum, n_tup_ins, last_vacuum
FROM rds_aurora.limitless_stat_all_tables
WHERE relname LIKE 'orders_ts%' ORDER BY relname LIMIT 10;
subcluster_id | subcluster_type | relname | n_ins_since_vacuum | n_tup_ins | last_vacuum
---------------+-----------------+----------------+--------------------+-----------+-------------
5 | shard | orders_ts00001 | 34779 | 196083 |
5 | shard | orders_ts00002 | 34632 | 194721 |
5 | shard | orders_ts00003 | 34950 | 195965 |
5 | shard | orders_ts00004 | 34745 | 197283 |
5 | shard | orders_ts00005 | 34879 | 195754 |
5 | shard | orders_ts00006 | 34340 | 194605 |
5 | shard | orders_ts00007 | 33779 | 192203 |
5 | shard | orders_ts00008 | 33826 | 191293 |
5 | shard | orders_ts00009 | 34660 | 194117 |
5 | shard | orders_ts00010 | 34569 | 195560 |
(10 rows)
```
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`.
+ `relname` (nome): o nome da tabela.
As demais colunas são as mesmas que em `pg_stat_all_tables`.
**limitless\$1stat\$1database**
Essa visualização contém estatísticas sobre todos os bancos de dados no grupo de fragmentos de banco de dados. Retorna uma linha por banco de dados por nó. Por exemplo:
```
postgres_limitless=> SELECT
subcluster_id,
subcluster_type,
datname,
blks_read,
blks_hit
FROM
rds_aurora.limitless_stat_database
WHERE
datname='postgres_limitless';
subcluster_id | subcluster_type | datname | blks_read | blks_hit
---------------+-----------------+--------------------+-----------+----------
1 | router | postgres_limitless | 484 | 34371314
2 | router | postgres_limitless | 673 | 33859317
3 | shard | postgres_limitless | 1299 | 17749550
4 | shard | postgres_limitless | 1094 | 17492849
5 | shard | postgres_limitless | 1036 | 17485098
6 | shard | postgres_limitless | 1040 | 17437257
(6 rows)
```
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`.
+ `datname` (nome): o nome do banco de dados.
As demais colunas são as mesmas que em `pg_stat_database`.
**limitless\$1stat\$1progress\$1vacuum**
Essa visualização contém informações sobre as operações de limpeza em andamento. Por exemplo:
```
postgres_limitless=> SELECT * FROM rds_aurora.limitless_stat_progress_vacuum;
-[ RECORD 1 ]----------+------------------
subcluster_id | 3
subcluster_type | shard
distributed_session_id | A56D96E2A5C9F426
pid | 5270
datname | postgres
nspname | public
relname | customer_ts2
phase | vacuuming heap
heap_blks_total | 130500
heap_blks_scanned | 100036
heap_blks_vacuumed | 0
index_vacuum_count | 0
max_dead_tuples | 11184810
num_dead_tuples | 0
-[ RECORD 2 ]----------+------------------
subcluster_id | 3
subcluster_type | shard
distributed_session_id | 56DF26A89EC23AB5
pid | 6854
datname | postgres
nspname | public
relname | sales_ts1
phase | vacuuming heap
heap_blks_total | 43058
heap_blks_scanned | 24868
heap_blks_vacuumed | 0
index_vacuum_count | 0
max_dead_tuples | 8569523
num_dead_tuples | 0
```
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`.
+ `distributed_session_id` (texto): o identificador da sessão que iniciou a operação de limpeza.
+ `datname` (nome): o banco de dados em que a limpeza está sendo feita.
+ `nspname` (nome): o nome do esquema da tabela que está sendo limpa. É `null` se a tabela que está sendo limpa não estiver no mesmo banco de dados ao qual o usuário está conectado.
+ `relname` (nome): o nome da tabela que está sendo limpa. É `null` se a tabela que está sendo limpa não estiver no mesmo banco de dados ao qual o usuário está conectado.
As demais colunas são as mesmas que em `pg_stat_progress_vacuum`.
**limitless\$1stat\$1statements**
Essa visualização fornece um meio de rastrear o planejamento e a execução de estatísticas de todas as instruções SQL executadas em todos os nós.
É necessário instalar a extensão [pg\$1stat\$1statements](https://www.postgresql.org/docs/current/pgstatstatements.html) para usar a visualização `limitless_stat_statements`.
```
-- CREATE EXTENSION must be run by a superuser
CREATE EXTENSION pg_stat_statements;
-- Verify that the extension is created on all nodes in the DB shard group
SELECT distinct node_id
FROM rds_aurora.limitless_stat_statements
LIMIT 10;
```
O exemplo a seguir mostra o uso da visualização `limitless_stat_statements`.
```
postgres_limitless=> SELECT
subcluster_id,
subcluster_type,
distributedqueryid,
username,
dbname,
sso_calls
FROM
rds_aurora.limitless_stat_statements;
subcluster_id | subcluster_type | distributedqueryid | username | dbname | sso_calls
---------------+-----------------+----------------------+-------------------------------------+--------------------+-----------
2 | router | | postgres | postgres_limitless | 0
2 | router | | postgres | postgres_limitless | 0
2 | router | | postgres | postgres_limitless | 0
2 | router | | postgres | postgres_limitless | 0
2 | router | | postgres | postgres_limitless | 0
2 | router | | postgres | postgres_limitless | 1
3 | shard | -7975178695405682176 | postgres | postgres_limitless |
[...]
```
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` para ou `shard`.
+ `distributedqueryid` (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.
+ `username` (nome): o usuário que consultou a instrução.
+ `dbname` (nome): o banco de dados onde a consulta foi executada.
+ `sso_calls` (nome) — o número de vezes que a instrução foi otimizada para um único fragmento.
As demais colunas são as mesmas que em [pg\$1stat\$1statements](https://www.postgresql.org/docs/current/pgstatstatements.html).
**limitless\$1stat\$1statements\$1info**
Essa visualização contém estatísticas para a visualização `limitless_stat_statements`. Cada linha contém dados para a visualização [pg\$1stat\$1statements\$1info](https://www.postgresql.org/docs/current/pgstatstatements.html#id-1.11.7.41.7) de cada nó. A coluna `subcluster_id` identifica cada nó.
```
postgres_limitless=> SELECT * FROM rds_aurora.limitless_stat_statements_info;
subcluster_id | subcluster_type | dealloc | stats_reset
---------------+-----------------+---------+-------------------------------
1 | router | 0 | 2023-06-30 21:22:09.524781+00
2 | router | 0 | 2023-06-30 21:21:40.834111+00
3 | shard | 0 | 2023-06-30 21:22:10.709942+00
4 | shard | 0 | 2023-06-30 21:22:10.740179+00
5 | shard | 0 | 2023-06-30 21:22:10.774282+00
6 | shard | 0 | 2023-06-30 21:22:10.808267+00
(6 rows)
```
O parâmetro de saída é o seguinte:
+ `subcluster_id` (texto): o ID do subcluster ao qual esse processo pertence.
As demais colunas são as mesmas que em [pg\$1stat\$1statements\$1info](https://www.postgresql.org/docs/current/pgstatstatements.html#id-1.11.7.41.7).
**limitless\$1stat\$1subclusters**
Essa visualização contém estatísticas de rede entre roteadores e outros nós. Ela contém uma linha por par de roteador e outro nó, por exemplo:
```
postgres_limitless=> SELECT * FROM rds_aurora.limitless_stat_subclusters;
orig_subcluster | orig_instance_az | dest_subcluster | dest_instance_az | latency_us | latest_collection | failed_requests | received_bytes | sent_bytes | same_az_requests | cross_az_requests | stat_reset_timestamp
-----------------+------------------+-----------------+------------------+------------+-------------------------------+-----------------+----------------+------------+------------------+-------------------+-------------------------------
3 | us-west-2b | 2 | us-west-2a | 847 | 2024-10-07 17:25:39.518617+00 | 0 | 35668633 | 92090171 | 0 | 302787 | 2024-10-05 12:39:55.239675+00
3 | us-west-2b | 4 | us-west-2b | 419 | 2024-10-07 17:25:39.546376+00 | 0 | 101190464 | 248795719 | 883478 | 0 | 2024-10-05 12:39:55.231218+00
3 | us-west-2b | 5 | us-west-2c | 1396 | 2024-10-07 17:25:39.52122+00 | 0 | 72864849 | 172086292 | 0 | 557726 | 2024-10-05 12:39:55.196412+00
3 | us-west-2b | 6 | us-west-2c | 729 | 2024-10-07 17:25:39.54828+00 | 0 | 35668584 | 92090171 | 0 | 302787 | 2024-10-05 12:39:55.247334+00
3 | us-west-2b | 7 | us-west-2a | 1702 | 2024-10-07 17:25:39.545307+00 | 0 | 71699576 | 171634844 | 0 | 556278 | 2024-10-05 12:39:52.715168+00
2 | us-west-2a | 3 | us-west-2b | 868 | 2024-10-07 17:25:40.293927+00 | 0 | 35659611 | 92011872 | 0 | 302817 | 2024-10-05 12:39:54.420758+00
2 | us-west-2a | 4 | us-west-2b | 786 | 2024-10-07 17:25:40.296863+00 | 0 | 102437253 | 251838024 | 0 | 895060 | 2024-10-05 12:39:54.404081+00
2 | us-west-2a | 5 | us-west-2c | 1232 | 2024-10-07 17:25:40.292021+00 | 0 | 71990027 | 168828110 | 0 | 545453 | 2024-10-05 12:39:36.769549+00
```
Os parâmetros de saída são os seguintes:
+ `orig_subcluster` (texto): o ID do roteador de onde as comunicações se originam
+ `orig_subcluster_az` (texto): a zona de disponibilidade (AZ) do roteador de origem
+ `dest_subcluster` (texto): o ID do nó de destino
+ `dest_subcluster_az` (texto): a última AZ coletada do nó de destino
+ `latency_us` (bigint): a última latência de rede coletada entre os nós, em microssegundos. O valor é `0` se o nó estiver inacessível.
+ `latest_collection` (data e hora): a data e hora da coleta mais recente de AZ e latência para o nó de destino
+ `failed_requests` (bigint): a contagem cumulativa de solicitações internas com falha
+ `received_bytes` (bigint): o número cumulativo estimado de bytes recebidos desse nó
+ `sent_bytes` (bigint): o número cumulativo estimado de bytes enviados para esse nó
+ `same_az_requests` (bigint): o número cumulativo de solicitações internas de banco de dados para esse nó quando ele está na mesma AZ do roteador de origem
+ `cross_az_requests` (bigint): o número cumulativo de solicitações internas de banco de dados para esse nó quando ele está em uma AZ diferente do roteador de origem
+ `stat_reset_timestamp` (data e hora): a data e hora de quando as estatísticas cumulativas dessa visualização foram redefinidas pela última vez
**limitless\$1statio\$1all\$1indexes**
Essa visualização contém estatísticas de entrada/saída (E/S) de todos os índices do grupo de fragmentos de banco de dados. Por exemplo:
```
postgres_limitless=> SELECT * FROM rds_aurora.limitless_statio_all_indexes WHERE relname like'customers_ts%';
subcluster_id | subcluster_type | schemaname | relname | indexrelname | idx_blks_read | idx_blks_hit
---------------+-----------------+------------+-------------------+-------------------------------------+ --------------+--------------
3 | shard | public | customers_ts00002 | customers_ts00002_customer_name_idx | 1 | 0
3 | shard | public | customers_ts00001 | customers_ts00001_customer_name_idx | 1 | 0
4 | shard | public | customers_ts00003 | customers_ts00003_customer_name_idx | 1 | 0
4 | shard | public | customers_ts00004 | customers_ts00004_customer_name_idx | 1 | 0
5 | shard | public | customers_ts00005 | customers_ts00005_customer_name_idx | 1 | 0
5 | shard | public | customers_ts00006 | customers_ts00006_customer_name_idx | 1 | 0
6 | shard | public | customers_ts00007 | customers_ts00007_customer_name_idx | 1 | 0
6 | shard | public | customers_ts00008 | customers_ts00008_customer_name_idx | 1 | 0
(8 rows)
```
**limitless\$1statio\$1all\$1tables**
Essa visualização contém estatísticas de entrada/saída (E/S) de todas as tabelas do grupo de fragmentos de banco de dados. Por exemplo:
```
postgres_limitless=> SELECT
subcluster_id,
subcluster_type,
schemaname,
relname,
heap_blks_read,
heap_blks_hit
FROM
rds_aurora.limitless_statio_all_tables
WHERE
relname LIKE 'customers_ts%';
subcluster_id | subcluster_type | schemaname | relname | heap_blks_read | heap_blks_hit
---------------+-----------------+------------+-------------------+----------------+---------------
3 | shard | public | customers_ts00002 | 305 | 57780
3 | shard | public | customers_ts00001 | 300 | 56972
4 | shard | public | customers_ts00004 | 302 | 57291
4 | shard | public | customers_ts00003 | 302 | 57178
5 | shard | public | customers_ts00006 | 300 | 56932
5 | shard | public | customers_ts00005 | 302 | 57386
6 | shard | public | customers_ts00008 | 300 | 56881
6 | shard | public | customers_ts00007 | 304 | 57635
(8 rows)
```
**limitless\$1tables**
Essa visualização contém informações sobre tabelas no Aurora PostgreSQL Limitless Database.
```
postgres_limitless=> SELECT * FROM rds_aurora.limitless_tables;
table_gid | local_oid | schema_name | table_name | table_status | table_type | distribution_key
-----------+-----------+-------------+-------------+--------------+-------------+------------------
5 | 18635 | public | placeholder | active | placeholder |
6 | 18641 | public | ref | active | reference |
7 | 18797 | public | orders | active | sharded | HASH (order_id)
2 | 18579 | public | customer | active | sharded | HASH (cust_id)
(4 rows)
```
**limitless\$1table\$1collocations**
Essa visualização contém informações sobre tabelas fragmentadas colocalizadas.
No exemplo a seguir, as tabelas `orders` e `customers` são colocalizadas, e as tabelas `users` e `followers` são colocalizadas. As tabelas colocalizadas têm o mesmo `collocation_id`.
```
postgres_limitless=> SELECT * FROM rds_aurora.limitless_table_collocations ORDER BY collocation_id;
collocation_id | schema_name | table_name
----------------+-------------+------------
2 | public | orders
2 | public | customers
5 | public | users
5 | public | followers
(4 rows)
```
**limitless\$1table\$1collocation\$1distributions**
Essa visualização mostra a distribuição de chaves para cada colocação.
```
postgres_limitless=> SELECT * FROM rds_aurora.limitless_table_collocation_distributions ORDER BY collocation_id, lower_bound;
collocation_id | subcluster_id | lower_bound | upper_bound
----------------+---------------+----------------------+----------------------
2 | 6 | -9223372036854775808 | -4611686018427387904
2 | 5 | -4611686018427387904 | 0
2 | 4 | 0 | 4611686018427387904
2 | 3 | 4611686018427387904 | 9223372036854775807
5 | 6 | -9223372036854775808 | -4611686018427387904
5 | 5 | -4611686018427387904 | 0
5 | 4 | 0 | 4611686018427387904
5 | 3 | 4611686018427387904 | 9223372036854775807
(8 rows)
```