# Referência do Amazon Aurora PostgreSQL Nos tópicos a seguir, é possível encontrar informações sobre agrupamentos, funções, parâmetros e eventos de espera no Amazon Aurora PostgreSQL. **Topics** + [Agrupamentos do Aurora PostgreSQL para EBCDIC e outras migrações de mainframe](#AuroraPostgreSQL.Reference.Collations.mainframe.migration) + [Agrupamentos permitidos no Aurora PostgreSQL.](PostgreSQL-Collations.md) + [Referência de funções do Aurora PostgreSQL](Appendix.AuroraPostgreSQL.Functions.md) + [Amazon Aurora PostgreSQL parameters](AuroraPostgreSQL.Reference.ParameterGroups.md) + [Eventos de espera do Amazon Aurora PostgreSQL](AuroraPostgreSQL.Reference.Waitevents.md) ## Agrupamentos do Aurora PostgreSQL para EBCDIC e outras migrações de mainframe A migração de aplicações de mainframe para novas plataformas, como a AWS, preserva de forma ideal o comportamento da aplicação. Preservar o comportamento da aplicação em uma nova plataforma exatamente como era no mainframe requer que os dados migrados sejam agrupados usando as mesmas regras de agrupamento e classificação. Por exemplo, muitas soluções de migração Db2 transferem valores nulos para u0180 (posição Unicode 0180), portanto esses agrupamentos classificam u0180 primeiro. Esse é um exemplo de como os agrupamentos podem variar em relação ao mainframe de origem e por que é necessário escolher um agrupamento que seja melhor mapeado para o agrupamento EBCDIC original. O Aurora PostgreSQL 14.3 e versões posteriores fornecem muitos agrupamentos ICU e EBCDIC para oferecer suporte a essa migração para a AWS usando o serviço AWS Mainframe Modernization. Para saber mais sobre esse serviço, consulte [O que é o AWS Mainframe Modernization?](https://docs.aws.amazon.com/m2/latest/userguide/what-is-m2.html) Na tabela a seguir, você pode encontrar agrupamentos fornecidos pelo Aurora PostgreSQL. Esses agrupamentos seguem as regras do EBCDIC e garantem que as aplicações de mainframe funcionem da mesma forma na AWS como funcionavam no ambiente de mainframe. O nome do agrupamento inclui a página de código relevante (cp*nnnn*) para que você possa escolher o agrupamento apropriado para sua a origem do seu mainframe. Por exemplo, use `en-US-cp037-x-icu` para obter o comportamento de agrupamento de dados EBCDIC originados de uma aplicação de mainframe que usou a página de código 037. | Agrupamentos EBCDIC | Agrupamentos do AWS Blu Age | Agrupamentos do AWS Micro Focus | | --- | --- | --- | | da-DK-cp1142-x-icu | da-DK-cp1142b-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-cp1145m-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-cp1144m-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 | – | Para saber mais sobre o AWS Blu Age, consulte [Tutorial: Tempo de execução gerenciado para AWS Blu Age](https://docs.aws.amazon.com/m2/latest/userguide/tutorial-runtime-ba.html) no *Guia do usuário do AWS Mainframe Modernization*. Para obter mais informações sobre como trabalhar com o AWS Micro Focus, consulte [Tutorial: Tempo de execução gerenciado para Micro Focus](https://docs.aws.amazon.com/m2/latest/userguide/tutorial-runtime.html) no *Guia do usuário do AWS Mainframe Modernization*. Para obter mais informações sobre como gerenciar agrupamentos no PostgreSQL, consulte [Collation Support](https://www.postgresql.org/docs/current/collation.html) (Compatibilidade com agrupamentos) na documentação do PostgreSQL. # Agrupamentos permitidos no Aurora PostgreSQL. Agrupamentos são conjuntos de regras que determinam como as strings de caracteres armazenadas no banco de dados são classificadas e comparadas. Eles desempenham um papel fundamental no sistema de computador e são incluídos como parte do sistema operacional. Os agrupamentos mudam com o tempo quando novos caracteres são adicionados aos idiomas ou quando ocorrem alterações nas regras de ordenação. As bibliotecas de agrupamentos definem regras e algoritmos específicos para um agrupamento. As bibliotecas de agrupamentos mais populares usadas no PostgreSQL são GNU C (glibc) e Componentes Internacionais para Unicode (ICU). Por padrão, o Aurora PostgreSQL usa o agrupamento glibc que inclui ordens de classificação de caracteres Unicode para sequências de caracteres de vários bytes. Quando você cria um cluster de banco de dados do Aurora PostgreSQL, ele verifica o agrupamento disponível no sistema operacional. Os parâmetros do PostgreSQL `LC_COLLATE` e `LC_CTYPE` do comando `CREATE DATABASE` são usados para especificar um agrupamento, que representa o agrupamento padrão nesse banco de dados. Como alternativa, você também pode usar o parâmetro `LOCALE` em `CREATE DATABASE` para definir esses parâmetros. Isso determina o agrupamento padrão para strings de caracteres no banco de dados e as regras para classificar caracteres como letras, números ou símbolos. Você também pode escolher um agrupamento para usar em uma coluna, um índice ou uma consulta. O Aurora PostgreSQL depende da biblioteca glibc no sistema operacional para oferecer suporte a agrupamentos. A instância do Aurora PostgreSQL é atualizada periodicamente com as versões mais recentes do sistema operacional. Essas atualizações às vezes incluem uma versão mais recente da biblioteca glibc. Em situações raras, as versões mais recentes da glibc alteram a ordem de classificação ou o agrupamento de alguns caracteres, o que pode fazer com que os dados sejam classificados de forma diferente ou produzam entradas de índice inválidas. Se você descobrir problemas na ordem de classificação para agrupamento durante uma atualização, poderá ser necessário recompilar os índices. Para reduzir os possíveis impactos das atualizações da glibc, o Aurora PostgreSQL agora inclui uma biblioteca de agrupamentos padrão independente. Essa biblioteca de agrupamentos está disponível no Aurora PostgreSQL 14.6, 13.9, 12.13, 11.18 e versões secundárias mais recentes. É compatível com glibc 2.26-59.amzn2 e oferece estabilidade da ordem de classificação para evitar resultados de consulta incorretos. # Referência de funções do Aurora PostgreSQL Você pode encontrar uma lista de funções do Aurora PostgreSQL disponíveis para clusters de bancos de dados Aurora que executam o mecanismo de banco de dados Aurora PostgreSQL, edição compatível com PostgreSQL. Essas funções do Aurora PostgreSQL são adicionadas às funções do PostgreSQL padrão. Para obter mais informações sobre funções padrão do PostgreSQL, consulte [PostgreSQL – Funções e operadores](https://www.postgresql.org/docs/current/functions.html). ## Visão geral Você pode usar as seguintes funções para instâncias de banco de dados do Amazon RDS que executam o 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 Informa o nome da instância de banco de dados à qual você está conectado. ## Sintaxe ``` aurora_db_instance_identifier() ``` ## Argumentos Nenhum ## Tipo de retorno String VARCHAR ## Observações de uso Essa função exibe o nome da instância de banco de dados do cluster da edição do Aurora compatível com PostgreSQL para a conexão do seu cliente ou aplicação de banco de dados. Essa função está disponível a partir do lançamento do Aurora PostgreSQL versões 13.7, 12.11, 11.16 e 10.21, e para todas as outras versões posteriores. ## Exemplos O exemplo a seguir mostra os resultados de uma chamada à função `aurora_db_instance_identifier`. ``` => SELECT aurora_db_instance_identifier(); aurora_db_instance_identifier ------------------------------- test-my-instance-name ``` Você pode unir os resultados dessa função com a função `aurora_replica_status` para obter detalhes sobre a instância de banco de dados para sua conexão. [aurora\$1replica\$1status](aurora_replica_status.md) sozinho não mostra qual instância de banco de dados você está usando. O exemplo a seguir mostra como. ``` => 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 Exibe o status do gerenciador de cache do cluster. ## Sintaxe ``` aurora_ccm_status() ``` ## Argumentos Nenhum. ## Tipo de retorno Registro SETOF com as seguintes colunas: + `buffers_sent_last_minute`: quantos buffers foram enviados ao leitor designado no último minuto. + `buffers_found_last_minute`: o número de buffers acessados com frequência que foram identificados durante o último minuto. + `buffers_sent_last_scan`: quantos buffers foram enviados ao leitor designado durante a última verificação completa do cache em buffer. + `buffers_found_last_scan`: quantos buffers acessados com frequência foram enviados durante a última verificação completa do cache em buffer. Os buffers que já estão em cache no leitor designado não são enviados. + `buffers_sent_current_scan`: quantos buffers foram enviados durante a verificação atual. + `buffers_found_current_scan`: o número de buffers acessados com frequência identificados na verificação atual. + `current_scan_progress`: quantos buffers foram visitados durante a verificação atual até agora. ## Observações de uso É possível usar essa função para verificar e monitorar o recurso de gerenciamento de cache de cluster (CCM). Essa função opera somente quando o CCM está ativo no cluster de banco de dados do Aurora PostgreSQL. Para usar essa função, conecte-se à instância de banco de dados de gravação no cluster de banco de dados do Aurora PostgreSQL. Ative o CCM para um cluster de banco de dados do Aurora PostgreSQL definindo a opção `apg_ccm_enabled` como 1 no grupo de parâmetros de cluster de banco de dados personalizado. Para saber como, consulte [Configuração do gerenciamento de cache do cluster](AuroraPostgreSQL.cluster-cache-mgmt.md#AuroraPostgreSQL.cluster-cache-mgmt.Configure). O gerenciamento de cache do cluster está ativo em um cluster de banco de dados do Aurora PostgreSQL quando o cluster tem uma instância do leitor do Aurora configurada da seguinte forma: + A instância do leitor do Aurora usa o mesmo tipo e tamanho de classe que a instância de banco de dados da instância do gravador do cluster. + A instância do leitor do Aurora está configurada como Nível 0 para o cluster. Se o cluster tiver mais de um leitor, esse será o único leitor Nível 0. A definição de mais de um leitor como Nível 0 desativa o CCM. Quando o CCM está desativado, a chamada dessa função retornará a seguinte mensagem de erro: ``` ERROR: Cluster Cache Manager is disabled ``` Também é possível usar a extensão pg\$1buffercache do PostgreSQL para analisar o cache do buffer. Para obter mais informações, consulte [pg\$1buffercache](https://www.postgresql.org/docs/current/pgbuffercache.html) na documentação do PostgreSQL. Para obter mais informações, consulte [Introdução ao gerenciamento de cache do cluster do Aurora PostgreSQL](https://aws.amazon.com/blogs/database/introduction-to-aurora-postgresql-cluster-cache-management/). ## Exemplos O exemplo a seguir mostra os resultados de uma chamada à função `aurora_ccm_status`. Este primeiro exemplo mostra as estatísticas do CCM. ``` => SELECT * FROM aurora_ccm_status(); buffers_sent_last_minute | buffers_found_last_minute | buffers_sent_last_scan | buffers_found_last_scan | buffers_sent_current_scan | buffers_found_current_scan | current_scan_progress --------------------------+---------------------------+------------------------+-------------------------+---------------------------+----------------------------+----------------------- 2242000 | 2242003 | 17920442 | 17923410 | 14098000 | 14100964 | 15877443 ``` Para obter detalhes mais completos, use a exibição expandida, conforme mostrado a seguir: ``` \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 ``` Este exemplo mostra como verificar a taxa de aquecimento e a porcentagem de aquecimento. ``` => 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 Exibe o status de todas as instâncias do Aurora, incluindo as réplicas em um cluster de banco de dados global do Aurora. ## Sintaxe ``` aurora_global_db_instance_status() ``` ## Argumentos Nenhum ## Tipo de retorno Registro SETOF com as seguintes colunas: + `server_id`: o identificador da instância de banco de dados. + `session_id`: o identificador exclusivo da sessão. O valor de `MASTER_SESSION_ID` identifica a instância de banco de dados do leitor (primário). + `aws_region`: a Região da AWS em que essa instância de banco de dados global é executada. Para obter uma lista de regiões, consulte [Disponibilidade de regiões](Concepts.RegionsAndAvailabilityZones.md#Aurora.Overview.Availability). + `durable_lsn`: o número de sequência de log (LSN) que se tornou durável no armazenamento. Um número de sequência de log (LSN) é um número sequencial exclusivo que identifica um registo no log de transações do banco de dados. LSNs são ordenados de forma que um LSN maior represente uma transação posterior. + `highest_lsn_rcvd`: o LSN mais alto recebido pela instância de banco de dados do gravador. + `feedback_epoch`: a época que a instância de banco de dados usa ao gerar informações de standby a quente. *Standby a quente* é uma instância de banco de dados que oferece suporte às conexões e às consultas quando o banco de dados primário está no modo de recuperação ou de standby. As informações de standby a quente incluem a época (ponto no tempo) e outros detalhes sobre a instância de banco de dados que está sendo usada como standby a quente. Para obter mais informações, consulte [Hot Standby](https://www.postgresql.org/docs/current/hot-standby.html) na documentação do PostgreSQL. + `feedback_xmin`: o ID mínimo (mais antigo) da transação ativa usado pela instância de banco de dados. + `oldest_read_view_lsn`: o LSN mais antigo usado pela instância de banco de dados para fazer a leitura no armazenamento. + `visibility_lag_in_msec`: o tempo de atraso dessa instância de banco de dados em relação à instância de banco de dados do gravador, em milissegundos. ## Observações de uso Essa função mostra estatísticas de replicação de um cluster de banco de dados do Aurora. Para cada instância de banco de dados do Aurora PostgreSQL no cluster, a função mostra uma linha de dados que inclui todas as réplicas entre regiões em uma configuração de banco de dados global. É possível executar essa função em qualquer instância em um cluster de banco de dados do Aurora PostgreSQL ou em um banco de dados global do Aurora PostgreSQL. A função retorna detalhes sobre o atraso de todas as instâncias de réplica. Para saber mais sobre o monitoramento de atraso usando essa função (`aurora_global_db_instance_status`) ou usando `aurora_global_db_status`, consulte [Monitorar banco de dados globais baseados no Aurora PostgreSQL](aurora-global-database-monitoring.md#aurora-global-database-monitoring.postgres). Para obter mais informações sobre bancos de dados globais do Aurora, consulte [Visão geral do Amazon Aurora Global Database](aurora-global-database.md#aurora-global-database-overview). Para obter os conceitos básicos sobre bancos de dados globais do Aurora, consulte [Conceitos básicos do Amazon Aurora Global Database](aurora-global-database-getting-started.md) ou [Perguntas frequentes sobre o Amazon Aurora](https://aws.amazon.com/rds/aurora/faqs/). ## Exemplos Este exemplo mostra as estatísticas de instâncias entre regiões. ``` => 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 ``` Este exemplo mostra como verificar o atraso de uma réplica global em milissegundos. ``` => 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 ``` Este exemplo mostra como verificar o atraso mínimo, máximo e médio por Região da AWS na configuração do banco de dados global. ``` => SELECT 'Secondary' global_role, aws_region, min(visibility_lag_in_msec) min_lag_in_msec, max(visibility_lag_in_msec) max_lag_in_msec, round(avg(visibility_lag_in_msec),0) avg_lag_in_msec FROM aurora_global_db_instance_status() WHERE aws_region NOT IN (SELECT aws_region FROM aurora_global_db_instance_status() WHERE session_id='MASTER_SESSION_ID') GROUP BY aws_region UNION ALL SELECT 'Primary' global_role, aws_region, NULL, NULL, NULL FROM aurora_global_db_instance_status() WHERE session_id='MASTER_SESSION_ID' ORDER BY 1, 5; global_role | aws_region | min_lag_in_msec | max_lag_in_msec | avg_lag_in_msec ------------+--------------+-----------------+-----------------+----------------- Primary | eu-west-1 | [NULL] | [NULL] | [NULL] Secondary | eu-central-1 | 133 | 133 | 133 Secondary | eu-west-2 | 0 | 495 | 248 ``` # aurora\$1global\$1db\$1status Exibe informações sobre diversos aspectos do atraso do banco de dados Aurora global, especificamente o atraso do armazenamento do Aurora subjacente (o chamado atraso de durabilidade) e o atraso entre o objetivo de ponto de recuperação (RPO). ## Sintaxe ``` aurora_global_db_status() ``` ## Argumentos Nenhum. ## Tipo de retorno Registro SETOF com as seguintes colunas: + `aws_region`: a Região da AWS em que esse cluster de banco de dados está. Para obter uma lista completa de Regiões da AWS por mecanismo, consulte [Regiões e zonas de disponibilidade](Concepts.RegionsAndAvailabilityZones.md). + `highest_lsn_written`: o número de sequência de logs (LSN) mais alto nesse cluster de banco de dados no momento. Um número de sequência de log (LSN) é um número sequencial exclusivo que identifica um registo no log de transações do banco de dados. LSNs são ordenados de forma que um LSN maior represente uma transação posterior. + `durability_lag_in_msec`: a diferença nos valores de carimbo de data/hora entre `highest_lsn_written` em um cluster de banco de dados secundário e `highest_lsn_written` no cluster de banco de dados primário. Um valor de -1 identifica o cluster de banco de dados primário do banco de dados Aurora global. + `rpo_lag_in_msec`: o atraso do objetivo de ponto de recuperação (RPO). O atraso do RPO é o tempo necessário para que a transação COMMIT mais recente do usuário seja armazenada em um cluster de banco de dados secundário após ser armazenada no cluster de banco de dados primário de um banco de dados Aurora global. Um valor igual a -1 denota o cluster de banco de dados primário (e, portanto, o atraso não é relevante). Em termos simples, essa métrica calcula o objetivo do ponto de recuperação de cada cluster de banco de dados do Aurora PostgreSQL no banco de dados Aurora global, ou seja, quantos dados poderão ser perdidos se houver uma interrupção. Tal como o atraso, o RPO é medido em tempo. + `last_lag_calculation_time`: o carimbo de data/hora que especifica quando os valores foram calculados pela última vez para `durability_lag_in_msec` e `rpo_lag_in_msec`. Um valor de tempo como `1970-01-01 00:00:00+00` indica que este é o cluster de banco de dados primário. + `feedback_epoch`: a época que o cluster de banco de dados secundário usa ao gerar informações de standby a quente. *Standby a quente* é uma instância de banco de dados que oferece suporte às conexões e às consultas quando o banco de dados primário está no modo de recuperação ou de standby. As informações de standby a quente incluem a época (ponto no tempo) e outros detalhes sobre a instância de banco de dados que está sendo usada como standby a quente. Para obter mais informações, consulte [Hot Standby](https://www.postgresql.org/docs/current/hot-standby.html) na documentação do PostgreSQL. + `feedback_xmin`: o ID mínimo (mais antigo) da transação ativa usado por um cluster de banco de dados secundário. ## Observações de uso Todas as versões do Aurora PostgreSQL atualmente disponíveis são compatíveis com essa função. Esta função mostra estatísticas de replicação de um banco de dados do Aurora. A função mostra uma linha para cada cluster de banco de dados em um banco de dados global do Aurora PostgreSQL. É possível executar essa função em qualquer instância em um banco de dados global do Aurora PostgreSQL. Para avaliar o atraso de replicação de banco de dados global do Aurora, que é o atraso de dados visível, consulte [aurora\$1global\$1db\$1instance\$1status](aurora_global_db_instance_status.md). Para saber mais sobre o uso de `aurora_global_db_status` e de `aurora_global_db_instance_status` para monitorar o atraso do banco de dados global do Aurora, consulte [Monitorar banco de dados globais baseados no Aurora PostgreSQL](aurora-global-database-monitoring.md#aurora-global-database-monitoring.postgres). Para obter mais informações sobre bancos de dados globais do Aurora, consulte [Visão geral do Amazon Aurora Global Database](aurora-global-database.md#aurora-global-database-overview). ## Exemplos Este exemplo mostra como exibir estatísticas de armazenamento entre regiões. ``` => 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 Lista todas as funções integradas do Aurora PostgreSQL disponíveis, juntamente com breves descrições e detalhes da função. ## Sintaxe ``` aurora_list_builtins() ``` ## Argumentos Nenhum ## Tipo de retorno Registro SETOF ## Exemplos O exemplo a seguir mostra os resultados de uma chamada à função `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 Exibe o status de todos os nós de leitor do Aurora PostgreSQL. ## Sintaxe ``` aurora_replica_status() ``` ## Argumentos Nenhum ## Tipo de retorno Registro SETOF com as seguintes colunas: + `server_id`: o DB de instância de banco de dados (identificador). + `session_id`: um identificador exclusivo da sessão atual, retornado para instâncias primárias e do leitor da seguinte forma: + Para a instância principal, `session_id` é sempre ``MASTER_SESSION_ID’`. + Para instâncias de leitor, `session_id` é sempre o `UUID` (identificador universalmente exclusivo) da instância do leitor. + `durable_lsn`: o número de sequência de log (LSN) que foi salvo no armazenamento. + Para o volume principal, o LSN (VDL) durável do volume principal que está atualmente em vigor. + Para quaisquer volumes secundários, o VDL do principal até o secundário que foi aplicado com êxito. **nota** Um número de sequência de log (LSN) é um número sequencial exclusivo que identifica um registo no log de transações do banco de dados. Os LSNs são ordenados de forma que um LSN maior represente uma transação ocorrida posteriormente na sequência. + `highest_lsn_rcvd`: o LSN mais alto (mais recente) recebido pela instância de banco de dados da instância de banco de dados do gravador. + `current_read_lsn`: o LSN do snapshot mais recente que foi aplicado a todos os leitores. + `cur_replay_latency_in_usec`: o número de microssegundos que se espera para reproduzir o log no secundário. + `active_txns`: o número de transações atualmente ativas. + `is_current`: não usado. + `last_transport_error`: código do último erro de replicação. + `last_error_timestamp`: carimbo de data/hora do último erro de replicação. + `last_update_timestamp`: carimbo de data/hora da última atualização para o status da réplica. No Aurora PostgreSQL 13.9, o valor `last_update_timestamp` da instância de banco de dados com que você tem conexão é definido como `NULL`. + `feedback_xmin`: o feedback\$1xmin de standby a quente da réplica. O ID mínimo (mais antigo) de transação ativo usado pela instância de banco de dados. + `feedback_epoch`: a época que a instância de banco de dados usa quando gera informações de standby a quente. + `replica_lag_in_msec`: o tempo de atraso da instância do leitor em relação à instância do gravador, em milissegundos. + `log_stream_speed_in_kib_per_second`: a taxa de transferência do fluxo de logs em kilobytes por segundo. + `log_buffer_sequence_number`: o número da sequência do buffer de log. + `oldest_read_view_trx_id`: não usado. + `oldest_read_view_lsn`: o LSN mais antigo usado pela instância de banco de dados para fazer a leitura no armazenamento. + `pending_read_ios`: a página pendente indica que ainda há pendência na réplica. + `read_ios`: o número total de leituras de página na réplica. + `iops`: não usado. + `cpu`: uso da CPU do Aurora Storage Daemon para cada nó no cluster. Para obter mais informações sobre o uso da CPU pela instância, consulte [Métricas no nível da instância do Amazon Aurora](Aurora.AuroraMonitoring.Metrics.md#Aurora.AuroraMySQL.Monitoring.Metrics.instances). ## Observações de uso Todas as versões do Aurora PostgreSQL atualmente disponíveis são compatíveis com essa função. A função `aurora_replica_status` retorna valores do gerenciador de status de réplica de um cluster de banco de dados do Aurora PostgreSQL. Você pode usar essa função para obter informações sobre o status da replicação em seu cluster de banco de dados do Aurora PostgreSQL, como métricas para todas as instâncias de banco de dados no cluster de banco de dados do Aurora. Por exemplo, você pode fazer o seguinte: + **Obtenha informações sobre o tipo de instância (gravador, leitor) no cluster de banco de dados do Aurora PostgreSQL**: você pode obter essas informações conferindo os valores das seguintes colunas: + `server_id`: contém o nome da instância que você especificou quando criou a instância. Em alguns casos, como para a instância principal (gravador), o nome geralmente é criado para você anexando *-instância-1* ao nome criado para o cluster de banco de dados do Aurora PostgreSQL. + `session_id`: o campo `session_id` indica se a instância é um leitor ou um gravador. Para uma instância de gravador, `session_id` é sempre definido como `"MASTER_SESSION_ID"`. Para uma instância de leitor, `session_id` é definido como o `UUID` do leitor específico. + **Diagnosticar problemas comuns de replicação, como atraso de réplica**: o atraso da réplica é o tempo em milissegundos em que o cache de página de uma instância de leitor está atrasado em relação à instância de gravador. Esse atraso ocorre porque os clusters do Aurora usam replicação assíncrona, conforme descrito em [Replicação com o Amazon Aurora](Aurora.Replication.md). Ele é mostrado na coluna `replica_lag_in_msec`, nos resultados retornados por essa função. O atraso também pode ocorrer quando uma consulta é cancelada devido a conflitos com a recuperação em um servidor em espera. Você pode conferir `pg_stat_database_conflicts()` para verificar se esse conflito está causando o atraso da réplica (ou não). Para obter mais informações, consulte [Coletor de estatísticas](https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-DATABASE-CONFLICTS-VIEW) na *documentação do PostgreSQL*. Para saber mais sobre alta disponibilidade e replicação, consulte [Perguntas frequentes sobre o Amazon Aurora](https://aws.amazon.com/rds/aurora/faqs/#High_Availability_and_Replication). O Amazon CloudWatch armazena resultados `replica_lag_in_msec` ao longo do tempo, como a métrica do `AuroraReplicaLag`. Para obter mais informações sobre o uso de métricas do CloudWatch para o Aurora, consulte [Monitorar métricas do Amazon Aurora com o Amazon CloudWatch](monitoring-cloudwatch.md). Para saber mais sobre a solução de problemas de réplicas de leitura e reinicializações do Aurora, consulte [Por que minha réplica de leitura do Amazon Aurora ficou atrasada e foi reiniciada?](https://aws.amazon.com/premiumsupport/knowledge-center/aurora-read-replica-restart/) no [AWS Support Center](https://console.aws.amazon.com/support/home#/). ## Exemplos O exemplo a seguir mostra como obter o status de replicação de todas as instâncias em um cluster de banco de dados do Aurora PostgreSQL: ``` => SELECT * FROM aurora_replica_status(); ``` O exemplo a seguir mostra a instância do gravador no cluster de banco de dados `docs-lab-apg-main` do 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 ``` O exemplo a seguir lista todas as instâncias de leitor em um 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) ``` O exemplo a seguir lista todas as instâncias, o atraso de cada instância em relação ao gravador e o tempo desde a última atualização: ``` => 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 Exibe uma linha por processo do servidor, mostrando informações relacionadas à atividade atual desse processo. ## Sintaxe ``` aurora_stat_activity(); ``` ## Argumentos Nenhum ## Tipo de retorno Exibe uma linha por processo do servidor. Além das colunas `pg_stat_activity`, o seguinte campo é adicionado: + planid: identificador do plano ## Observações de uso Uma visualização complementar para `pg_stat_activity` exibindo as mesmas colunas com uma coluna `plan_id` adicional que mostra o plano de execução da consulta atual. `aurora_compute_plan_id` deve estar habilitado para que a visualização exiba um plan\$1id. Essa função está disponível para o Aurora PostgreSQL versões 14.10, 15.5 e todas as outras versões posteriores. ## Exemplos O exemplo de consulta abaixo agrega a carga superior por 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 o plano usado para query\$1id mudar, um novo plan\$1id será relatado por aurora\$1stat\$1activity. ``` count | query_id | plan_id -------+----------------------+------------- 10 | -5471422286312252535 | 1602979607 1 | -6907107586630739258 | -1809935983 1 | -2446282393000597155 | -207532066 (3 rows) ``` # aurora\$1stat\$1backend\$1waits Exibe estatísticas da atividade de espera de um processo de backend específico. ## Sintaxe ``` aurora_stat_backend_waits(pid) ``` ## Argumentos `pid`: o ID do processo de backend. É possível obter os IDs de processos usando a visualização `pg_stat_activity`. ## Tipo de retorno Registro SETOF com as seguintes colunas: + `type_id`: um número que denota o tipo de evento de espera, como `1` para um bloqueio leve (`LWLock`), `3` para um bloqueio ou `6` para uma sessão de cliente, para citar alguns exemplos. Esses valores se tornam significativos ao unir os resultados dessa função com colunas da função `aurora_stat_wait_type`, como mostrado em [Exemplos](#aurora_stat_backend_waits-examples). + `event_id`: um número de identificação para o evento de espera. Una esse valor com as colunas de `aurora_stat_wait_event` para obter nomes de eventos significativos. + `waits`: uma contagem do número de esperas acumuladas para o ID do processo especificado. + `wait_time`: tempo de espera em milissegundos. ## Observações de uso É possível usar essa função para analisar eventos de espera específicos de backend (sessão) que ocorreram desde que uma conexão foi aberta. Para obter informações mais significativas sobre os nomes e os tipos de evento de espera, combine as funções `aurora_stat_wait_type` e `aurora_stat_wait_event`, usando JOIN como mostrado nos exemplos. ## Exemplos Este exemplo mostra todas as esperas, os tipos e os nomes dos eventos de um processo de backend ID 3027. ``` => SELECT type_name, event_name, waits, wait_time FROM aurora_stat_backend_waits(3027) NATURAL JOIN aurora_stat_wait_type() NATURAL JOIN aurora_stat_wait_event(); type_name | event_name | waits | wait_time -----------+------------------------+-------+------------ LWLock | ProcArrayLock | 3 | 27 LWLock | wal_insert | 423 | 16336 LWLock | buffer_content | 11840 | 1033634 LWLock | lock_manager | 23821 | 5664506 Lock | tuple | 10258 | 152280165 Lock | transactionid | 78340 | 1239808783 Client | ClientRead | 34072 | 17616684 IO | ControlFileSyncUpdate | 2 | 0 IO | ControlFileWriteUpdate | 4 | 32 IO | RelationMapRead | 2 | 795 IO | WALWrite | 36666 | 98623 IO | XactSync | 4867 | 7331963 ``` Este exemplo mostra os tipos de espera atuais e cumulativos e de eventos de espera para todas as sessões ativas (`pg_stat_activity state <> 'idle'`), mas sem a sessão atual que está invocando a função (`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 ``` Este exemplo mostra os três tipos principais de espera cumulativa e os eventos de espera de todas as sessões ativas (`pg_stat_activity state <> 'idle'`), exceto a sessão atual (`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` é uma exibição de estatísticas que mostra informações sobre gravações em cache do Optimized Reads. ## Sintaxe ``` aurora_stat_bgwriter() ``` ## Argumentos Nenhum ## Tipo de retorno Registro SETOF com todas as colunas `pg_stat_bgwriter` e as seguintes colunas adicionais. Para obter mais informações sobre as colunas `pg_stat_bgwriter`, consulte [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). Você pode redefinir as estatísticas dessa função usando `pg_stat_reset_shared("bgwriter")`. + `orcache_blks_written`: número total de gravações em cache de blocos de dados do optimized reads. + `orcache_blk_write_time`: se `track_io_timing` estiver ativado, ele rastreará o tempo total gasto gravando blocos de arquivos de dados em cache do optimized reads, em milissegundos. Para obter mais informações, consulte [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING). ## Observações de uso Essa função está disponível nas seguintes versões do Aurora PostgreSQL: + 15.4 e versões 15 posteriores + 14.9 e versões 14 posteriores ## Exemplos ``` => select * from aurora_stat_bgwriter(); -[ RECORD 1 ]-----------------+----------- orcache_blks_written | 246522 orcache_blk_write_time | 339276.404 ``` # aurora\$1stat\$1database Ele carrega todas as colunas de pg\$1stat\$1database e acrescenta novas colunas no final. ## Sintaxe ``` aurora_stat_database() ``` ## Argumentos Nenhum ## Tipo de retorno Registro SETOF com todas as colunas `pg_stat_database` e as seguintes colunas adicionais. Para obter mais informações sobre as colunas `pg_stat_database`, consulte [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`: número total de blocos compartilhados lidos do armazenamento do aurora nesse banco de dados. + `orcache_blks_hit`: número total de acessos ao cache do optimized reads nesse banco de dados. + `local_blks_read`: número total de blocos locais lidos nesse banco de dados. + `storage_blk_read_time`: se `track_io_timing` estiver ativado, ele rastreará o tempo total gasto lendo blocos de arquivos de dados do armazenamento do aurora, em milissegundos; caso contrário, o valor será zero. Para obter mais informações, consulte [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` estiver ativado, ele rastreará o tempo total gasto lendo blocos de arquivos de dados locais, em milissegundos; caso contrário, o valor será zero. Para obter mais informações, consulte [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` estiver ativado, ele rastreará o tempo total gasto lendo blocos de arquivos de dados do cache do optimized reads, em milissegundos; caso contrário, o valor será zero. Para obter mais informações, consulte [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING). **nota** O valor de `blks_read` é a soma de `storage_blks_read`, `orcache_blks_hit` e `local_blks_read`. O valor de `blk_read_time` é a soma de `storage_blk_read_time`, `orcache_blk_read_time` e `local_blk_read_time`. ## Observações de uso Essa função está disponível nas seguintes versões do Aurora PostgreSQL: + 15.4 e versões 15 posteriores + 14.9 e versões 14 posteriores ## Exemplos O exemplo a seguir mostra como ele carrega todas as colunas `pg_stat_database` e acrescenta seis novas colunas no final: ``` => 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 Relata a atividade cumulativa para cada tipo de operação de linguagem de manipulação de dados (DML) em um banco de dados em um cluster do Aurora PostgreSQL. ## Sintaxe ``` aurora_stat_dml_activity(database_oid) ``` ## Argumentos *database\$1oid* O ID do objeto (OID) do banco de dados no cluster do Aurora PostgreSQL. ## Tipo de retorno Registro SETOF ## Observações de uso A função `aurora_stat_dml_activity` só está disponível com o Aurora PostgreSQL versão 3.1 compatível com o mecanismo do PostgreSQL 11.6 e posteriores. Use essa função em clusters do Aurora PostgreSQL com um grande número de bancos de dados para identificar quais bancos de dados apresentam mais atividades de DML ou atividades de DML mais lentas ou ambas. A função `aurora_stat_dml_activity` retorna o número de vezes que as operações foram executadas e a latência cumulativa em microssegundos para as operações SELECT, INSERT, UPDATE e DELETE. O relatório inclui apenas operações DML bem-sucedidas. Você pode redefinir essa estatística usando a função de acesso de estatísticas do PostgreSQL `pg_stat_reset`. Você pode verificar a última vez que esta estatística foi redefinida usando a função `pg_stat_get_db_stat_reset_time`. Para obter mais informações sobre as funções de acesso a estatísticas do PostgreSQL, consulte [Coletor de estatísticas](https://www.postgresql.org/docs/9.1/monitoring-stats.html) na documentação do PostgreSQL. ## Exemplos O exemplo a seguir mostra como relatar estatísticas de atividades de DML para o banco de dados conectado. ``` ––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 ``` O exemplo a seguir mostra estatísticas de atividades de DML para todos os bancos de dados no cluster do Aurora PostgreSQL. Esse cluster tem dois bancos de dados,`postgres` e `mydb`. A lista separada por vírgulas corresponde aos campos `select_count`, `select_latency_microsecs`, `insert_count`, `insert_latency_microsecs`, `update_count`, `update_latency_microsecs`, `delete_count` e `delete_latency_microsecs`. O Aurora PostgreSQL cria e usa um banco de dados do sistema chamado `rdsadmin` para oferecer suporte a operações administrativas, como backups, restaurações, verificações de integridade, replicação e assim por diante. Essas operações de DML não têm impacto no cluster do 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) ``` O exemplo a seguir mostra estatísticas de atividade DML para todos os bancos de dados, organizadas em colunas para melhor legibilidade. ``` 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 ``` O exemplo a seguir mostra a latência cumulativa média (latência cumulativa dividida por contagem) para cada operação de DML para o banco de dados com o 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 Obtém a latência de confirmação cumulativa em microssegundos para bancos de dados do Aurora PostgreSQL. A *confirmação da latência* é medida como o tempo entre quando um cliente envia uma solicitação de confirmação e quando ele recebe a resposta afirmativa da confirmação. ## Sintaxe ``` aurora_stat_get_db_commit_latency(database_oid) ``` ## Argumentos *database\$1oid* O ID do objeto (OID) do banco de dados Aurora PostgreSQL. ## Tipo de retorno Registro SETOF ## Observações de uso O Amazon CloudWatch usa essa função para calcular a latência média de confirmação. Para obter mais informações sobre as métricas do Amazon CloudWatch e como solucionar problemas de alta latência de confirmação, consulte [Visualizar métricas no console do Amazon RDS](USER_Monitoring.md) e [Como tomar melhores decisões sobre o Amazon RDS com métricas do Amazon CloudWatch](https://aws.amazon.com/blogs/database/making-better-decisions-about-amazon-rds-with-amazon-cloudwatch-metrics/). Você pode redefinir essa estatística usando a função de acesso de estatísticas do PostgreSQL `pg_stat_reset`. Você pode verificar a última vez que esta estatística foi redefinida usando a função `pg_stat_get_db_stat_reset_time`. Para obter mais informações sobre as funções de acesso a estatísticas do PostgreSQL, consulte [Coletor de estatísticas](https://www.postgresql.org/docs/9.1/monitoring-stats.html) na documentação do PostgreSQL. ## Exemplos O exemplo a seguir obtém a latência de confirmação cumulativa para cada banco de dados no 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 ``` O exemplo a seguir obtém a latência de confirmação cumulativa para o banco de dados conectado no momento. Antes de chamar a função `aurora_stat_get_db_commit_latency`, o exemplo primeiro usa `\gset` para definir uma variável para o argumento `oid` e define seu valor do banco de dados conectado. ``` ––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 ``` O exemplo a seguir obtém a latência de confirmação cumulativa para o banco de dados `mydb` no cluster `pg_database`. Em seguida, ele redefine essa estatística usando a função `pg_stat_reset` e mostra os resultados. Finalmente, ele usa a função `pg_stat_get_db_stat_reset_time` para verificar a última vez que essa estatística foi redefinida. ``` => 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 o uso do log de gravação antecipada (WAL) por slot. ## Sintaxe ``` SELECT * FROM aurora_stat_logical_wal_cache() ``` ## Argumentos Nenhum ## Tipo de retorno Registro SETOF com as seguintes colunas: + `name`: o nome do slot de replicação. + `active_pid`: ID do processo walsender. + `cache_hit`: o número total de acessos ao cache wal desde a última redefinição. + `cache_miss`: o número total de perdas do cache wal desde a última redefinição. + `blks_read`: o número total de solicitações de leitura do cache wal. + `hit_rate`: a taxa de acertos do cache WAL (cache\$1hit/blks\$1read). + `last_reset_timestamp`: última vez que o contador foi redefinido. ## Observações de uso Essa função está disponível para as versões a seguir do Aurora PostgreSQL. + 15.2 e todas as versões posteriores. + 14.7 e versões posteriores. + 13.08 e versões posteriores + 12.12 e versões posteriores + 11.17 e versões posteriores ## Exemplos O exemplo a seguir mostra dois slots de replicação com somente uma função `aurora_stat_logical_wal_cache` ativa. ``` => 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 Relata o uso do contexto de memória para cada processo do PostgreSQL. ## Sintaxe ``` aurora_stat_memctx_usage() ``` ## Argumentos Nenhum ## Tipo de retorno Registro SETOF com as seguintes colunas: + `pid`: o ID do processo. + `name`: o nome do contexto da memória. + `allocated`: o número de bytes obtidos do subsistema de memória subjacente pelo contexto da memória. + `used`: o número de bytes confirmados nos clientes do contexto de memória. + `instances`: a contagem de contextos existentes desse tipo no momento. ## Observações de uso Essa função exibe o uso do contexto de memória para cada processo do PostgreSQL. Alguns processos são identificados como `anonymous`. Os processos não são expostos porque contêm palavras-chave restritas. Essa função está disponível para as seguintes versões do Aurora PostgreSQL: + 15.3 e versões 15 posteriores + 14.8 e versões 14 posteriores + 13.11 e versões 13 posteriores + 12.15 e versões 12 posteriores + 11.20 e versões 11 posteriores ## Exemplos O exemplo a seguir mostra os resultados de uma chamada à função `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) ``` Algumas palavras-chave restritas serão ocultadas, e a saída terá a seguinte aparência: ``` 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 Essa função mostra estatísticas de cache em camadas. ## Sintaxe ``` aurora_stat_optimized_reads_cache() ``` ## Argumentos Nenhum ## Tipo de retorno Registro SETOF com as seguintes colunas: + `total_size`: tamanho total do cache do optimized reads. + `used_size`: tamanho de página usado em cache do optimized reads. ## Observações de uso Essa função está disponível nas seguintes versões do Aurora PostgreSQL: + 15.4 e versões 15 posteriores + 14.9 e versões 14 posteriores ## Exemplos Veja a seguir um exemplo de saída em uma instância 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 Exibe uma linha para cada plano de execução monitorado. ## Sintaxe ``` aurora_stat_plans( showtext ) ``` ## Argumentos + showtext: mostra a consulta e o texto do plano. Os valores válidos são NULL, true ou false. True mostrará a consulta e o texto do plano. ## Tipo de retorno Exibe uma linha para cada plano monitorado que contém todas as colunas de `aurora_stat_statements` e as colunas adicionais a seguir. + planid: identificador do plano. + explain\$1plan: explica o texto do plano. + plan\$1type: + `no plan`: nenhum plano foi capturado. + `estimate`: plano capturado com custos estimados. + `actual`: plano capturado com EXPLAIN ANALYZE. + plan\$1captured\$1time: última vez que um plano foi capturado. ## Observações de uso `aurora_compute_plan_id` deve estar habilitado e `pg_stat_statements` deve estar em `shared_preload_libraries` para que os planos sejam monitorados. O número de planos disponíveis é controlado pelo valor definido no parâmetro `pg_stat_statements.max`. Quando `aurora_compute_plan_id` está habilitado, é possível monitorar os planos até esse valor especificado em `aurora_stat_plans`. Essa função está disponível para o Aurora PostgreSQL versões 14.10, 15.5 e todas as outras versões posteriores. ## Exemplos No exemplo abaixo, os dois planos que são para o identificador de consulta -5471422286312252535 são capturados e as estatísticas das declarações são monitoradas pelo 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 Redefine o contador para o cache lógico wal. ## Sintaxe Para redefinir um slot específico ``` SELECT * FROM aurora_stat_reset_wal_cache('slot_name') ``` Para redefinir todos os slots ``` SELECT * FROM aurora_stat_reset_wal_cache(NULL) ``` ## Argumentos `NULL` ou `slot_name` ## Tipo de retorno Mensagem de status, string de texto + Redefina o contador lógico do cache wal: mensagem de êxito. Esse texto é retornado quando a função é bem-sucedida. + Slot de replicação não encontrado. Tente novamente. – Mensagem de falha. Esse texto é retornado quando a função não é bem-sucedida. ## Observações de uso Essa função está disponível para as versões a seguir. + Aurora PostgreSQL 14.5 e posteriores + Aurora PostgreSQL versão 13.8 e posteriores + Aurora PostgreSQL versão 12.12 e posteriores + Aurora PostgreSQL versão 11.17 e posteriores ## Exemplos O exemplo a seguir usa a função `aurora_stat_reset_wal_cache` para redefinir um slot denominado `test_results` e, depois, tenta redefinir um slot que não existe. ``` => 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 Relata a utilização de recursos em tempo real, que consiste em métricas de recursos de backend e no uso da CPU para todos os processos de backend do Aurora PostgreSQL. ## Sintaxe ``` aurora_stat_resource_usage() ``` ## Argumentos Nenhum ## Tipo de retorno Registro SETOF com colunas: + pid: identificador de processo. + allocated\$1memory: memória total alocada por processo em bytes. + used\$1memory: memória realmente usada por processo em bytes. + cpu\$1usage\$1percent: porcentagem de uso de CPU do processo. ## Observações de uso Essa função exibe o uso de recursos de backend para cada processo de backend do Aurora PostgreSQL. Essa função está disponível para as seguintes versões do Aurora PostgreSQL: + Aurora PostgreSQL 17.5 e versões 17 posteriores + Aurora PostgreSQL 16.9 e versões 16 posteriores + Aurora PostgreSQL 15.13 e versões 15 posteriores + Aurora PostgreSQL 14.18 e versões 14 posteriores + Aurora PostgreSQL 13.21 e versões 13 posteriores ## Exemplos O exemplo a seguir mostra a saída da função `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 Exibe todas as colunas `pg_stat_statements` e adiciona mais colunas no final. ## Sintaxe ``` aurora_stat_statements(showtext boolean) ``` ## Argumentos *showtext booliano* ## Tipo de retorno Registro SETOF com todas as colunas `pg_stat_statements` e as seguintes colunas adicionais. Para obter mais informações sobre as colunas `pg_stat_statements`, consulte [https://www.postgresql.org/docs/current/pgstatstatements.html](https://www.postgresql.org/docs/current/pgstatstatements.html). Você pode redefinir as estatísticas dessa função usando `pg_stat_statements_reset()`. + `storage_blks_read`: número total de blocos compartilhados lidos do armazenamento do aurora de acordo com essa instrução. + `orcache_blks_hit`: número total de acessos ao cache do optimized reads nessa instrução. + `storage_blk_read_time`: se `track_io_timing` estiver habilitado, ele vai monitorar o tempo total gasto nessa declaração com a leitura de blocos compartilhados do armazenamento do Aurora, em milissegundos; caso contrário, o valor será zero. Para obter mais informações, consulte [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` estiver habilitado, ele vai monitorar o tempo total gasto nessa declaração com a leitura de blocos locais, em milissegundos; caso contrário, o valor será zero. Para obter mais informações, consulte [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` estiver habilitado, ele vai monitorar o tempo total gasto nessa declaração com a leitura de blocos compartilhados do cache de leituras otimizadas, em milissegundos; caso contrário, o valor será zero. Para obter mais informações, consulte [track\$1io\$1timing](https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING). + `total_plan_peakmem`: soma total dos valores de pico de memória durante a fase de planejamento para todas as chamadas para essa declaração. Para ver o pico médio de memória durante o planejamento da declaração, divida esse valor pelo número de chamadas. + `min_plan_peakmem`: o menor valor de pico de memória observado durante o planejamento em todas as chamadas para essa declaração. + `max_plan_peakmem`: o maior valor de pico de memória durante o planejamento observado em todas as chamadas para essa declaração. + `total_exec_peakmem`: soma total dos valores de pico de memória durante a fase de execução para todas as chamadas para essa declaração. Para ver o pico médio de memória durante a execução da declaração, divida esse valor pelo número de chamadas. + `min_exec_peakmem`: o menor valor de pico de memória, em bytes, observado durante a execução em todas as chamadas para essa declaração. + `max_exec_peakmem`: o maior valor de pico de memória, em bytes, observado durante a execução em todas as chamadas para essa declaração. **nota** `total_plan_peakmen`, `min_plan_peakmem` e `max_plan_peakmem` são monitorados apenas quando a configuração `pg_stat_statements.track_planning` está ativada. ## Observações de uso Para usar a função aurora\$1stat\$1statements(), é necessário incluir a extensão `pg_stat_statements` no parâmetro `shared_preload_libraries`. Essa função está disponível nas seguintes versões do Aurora PostgreSQL: + 15.4 e versões 15 posteriores + 14.9 e versões 14 posteriores As colunas que mostram o pico de memória estão disponíveis nas seguintes versões: + 16.3 e versões posteriores + 15.7 e versões posteriores + 14.12 e versões posteriores ## Exemplos O exemplo a seguir mostra como ele carrega todas as colunas pg\$1stat\$1statements e inclui 11 novas colunas no final: ``` => 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 Relata informações de eventos de espera para a instância de banco de dados Aurora PostgreSQL. ## Sintaxe ``` aurora_stat_system_waits() ``` ## Argumentos Nenhum ## Tipo de retorno Registro SETOF ## Observações de uso Essa função retorna o número cumulativo de esperas e o tempo de espera cumulativo para cada evento de espera gerado pela instância de banco de dados à qual você está conectado no momento. O conjunto de registros retornado inclui os seguintes campos: + `type_id`: o ID do tipo do evento de espera. + `event_id`: o ID do evento de espera. + `waits`: o número de vezes que o evento de espera ocorreu. + `wait_time`: a quantidade total de tempo em microssegundos gasto aguardando esse evento. As estatísticas retornadas por essa função são redefinidas quando uma instância de banco de dados é reiniciada. ## Exemplos O exemplo a seguir mostra os resultados de uma chamada à função `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 ``` O exemplo a seguir mostra como é possível usar essa função junto com `aurora_stat_wait_event` e `aurora_stat_wait_type` para produzir resultados mais legíveis. ``` => 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 Lista todos os eventos de espera compatíveis para o Aurora PostgreSQL. Para obter informações sobre eventos de espera do Aurora PostgreSQL, consulte [Eventos de espera do Amazon Aurora PostgreSQL](AuroraPostgreSQL.Reference.Waitevents.md). ## Sintaxe ``` aurora_stat_wait_event() ``` ## Argumentos Nenhum ## Tipo de retorno Registro SETOF com as seguintes colunas: + type\$1id: o ID do tipo do evento de espera. + event\$1id: o ID do evento de espera. + type\$1name: nome do tipo de espera + event\$1name: nome do evento de espera ## Observações de uso Para ver nomes de eventos com tipos de eventos em vez de IDs, use essa função junto com outras funções, como `aurora_stat_wait_type` e `aurora_stat_system_waits`. Os nomes de eventos de espera retornados por esta função são os mesmos que os retornados pela função `aurora_wait_report`. ## Exemplos O exemplo a seguir mostra os resultados de uma chamada à função `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 ``` O exemplo a seguir junta `aurora_stat_wait_type` e `aurora_stat_wait_event` para retornar nomes de tipos e nomes de eventos para melhorar a legibilidade. ``` => 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 Lista todos os tipos de espera compatíveis para o Aurora PostgreSQL. ## Sintaxe ``` aurora_stat_wait_type() ``` ## Argumentos Nenhum ## Tipo de retorno Registro SETOF com as seguintes colunas: + type\$1id: o ID do tipo do evento de espera. + type\$1name: nome do tipo de espera. ## Observações de uso Para ver nomes de eventos de espera com tipos de eventos de espera em vez de IDs, use essa função junto com outras funções, como `aurora_stat_wait_event` e `aurora_stat_system_waits`. Os nomes de tipos de espera retornados por esta função são os mesmos que os retornados pela função `aurora_wait_report`. ## Exemplos O exemplo a seguir mostra os resultados de uma chamada à função `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 Retorna o valor de string do número de versão do Amazon Aurora edição compatível com PostgreSQL. ## Sintaxe ``` aurora_version() ``` ## Argumentos Nenhum ## Tipo de retorno String CHAR ou VARCHAR ## Observações de uso Essa função exibe a versão do mecanismo de banco de dados do Amazon Aurora edição compatível com PostgreSQL. O número da versão é retornado como uma string formatada como *major*.*minor*.*patch*. Para obter mais informações sobre os número de versão do Aurora PostgreSQL, consulte [Número de versão do Aurora](AuroraPostgreSQL.Updates.md#AuroraPostgreSQL.Updates.Versions.AuroraNumber). Você pode escolher quando aplicar atualizações de versões secundárias definindo a janela de manutenção do cluster de banco de dados do Aurora PostgreSQL. Para saber como, consulte [Manutenção de um cluster de banco de dados do Amazon Aurora](USER_UpgradeDBInstance.Maintenance.md). A partir do lançamento das versões 13.3, 12.8, 11.13, 10.18 do Aurora PostgreSQL e para todas as outras posteriores, os números de versão do Aurora seguem os números de versão do PostgreSQL. Para obter mais informações sobre todas as versões do Aurora PostgreSQL, consulte [Atualizações do Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Updates.html) nas *Notas de lançamento do Aurora PostgreSQL*. ## Exemplos O exemplo a seguir mostra os resultados da chamada da função `aurora_version` em um cluster de banco de dados do Aurora PostgreSQL que executa o [PostgreSQL 12.7, Aurora PostgreSQL versão 4.2](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Updates.html#AuroraPostgreSQL.Updates.20180305.42), e depois executa a mesma função em um cluster que executa o [Aurora PostgreSQL versão 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 ``` Este exemplo mostra como usar a função com várias opções para obter mais detalhes sobre a versão do Aurora PostgreSQL. Este exemplo tem um número de versão do Aurora distinto do número de versão do 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) ``` Este próximo exemplo usa a função com as mesmas opções no exemplo anterior. Este exemplo não tem um número de versão do Aurora distinto do número de versão do 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 Retorna o número de sequência de log (LSN) usado para identificar o início de um registro no stream lógico do log de gravação antecipada (WAL) do volume de cluster do Aurora. ## Sintaxe ``` aurora_volume_logical_start_lsn() ``` ## Argumentos Nenhum ## Tipo de retorno `pg_lsn` ## Observações de uso Essa função identifica o início do registro no stream lógico de WAL para determinado volume de cluster do Aurora. Você pode usar essa função enquanto realiza um upgrade de versão principal usando a replicação lógica e a clonagem rápida do Aurora para determinar o LSN em que um snapshot ou clone de banco de dados é gerado. Depois, você pode usar a replicação lógica para transmitir continuamente os dados mais recentes registrados depois do LSN e sincronizar as alterações entre publicador e assinante. Para obter mais informações sobre como usar a replicação lógica para um upgrade de versão principal, consulte [Usar replicação lógica para realizar uma atualização de versão principal do Aurora PostgreSQL](AuroraPostgreSQL.MajorVersionUpgrade.md). Essa função está disponível nas seguintes versões do Aurora PostgreSQL: + Versão 15.2 e versões 15 posteriores + Versão 14.3 e versões 14 posteriores + Versão 13.6 e versões 13 posteriores + Versão 12.10 e versões 12 posteriores + Versão 11.15 e versões 11 posteriores + Versão 10.20 e versões 10 posteriores ## Exemplos Você pode obter o número de sequência de log (LSN) usando a seguinte consulta: ``` postgres=> SELECT aurora_volume_logical_start_lsn(); aurora_volume_logical_start_lsn --------------- 0/402E2F0 (1 row) ``` # aurora\$1wait\$1report Essa função mostra a atividade de eventos de espera por um período. ## Sintaxe ``` aurora_wait_report([time]) ``` ## Argumentos *time (opcional) * A hora em segundos. O padrão é 10 segundos. ## Tipo de retorno Registro SETOF com as seguintes colunas: + type\$1name: nome do tipo de espera + event\$1name: nome do evento de espera + wait: número de esperas + wait\$1time: tempo de espera em milissegundos + ms\$1per\$1wait: média de milissegundos pelo número de uma espera + waits\$1per\$1xact: média de esperas pelo número de uma transação + ms\$1per\$1wait: média de milissegundos pelo número de transações ## Observações de uso Essa função está disponível a partir do Aurora PostgreSQL versão 1.1 compatível com PostgreSQL 9.6.6 e versões posteriores. Para usar essa função, você precisa primeiro criar a extensão `aurora_stat_utils` do Aurora PostgreSQL, da seguinte forma: ``` => CREATE extension aurora_stat_utils; CREATE EXTENSION ``` Para obter mais informações sobre as versões de extensão do Aurora PostgreSQL disponíveis, consulte [Versões de extensão do Amazon Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Extensions.html) em *Notas de lançamento do Aurora PostgreSQL*. Essa função calcula os eventos de espera no nível da instância comparando dois snapshots de dados estatísticos da função aurora\$1stat\$1system\$1waits() e das visualizações estatísticas pg\$1stat\$1database do PostgreSQL. Para obter mais informações sobre `aurora_stat_system_waits()` e `pg_stat_database`, consulte [Coletor de estatísticas](https://www.postgresql.org/docs/current/monitoring-stats.html#PG-STAT-DATABASE-VIEW) na *documentação do PostgreSQL*. Quando executada, essa função tira um snapshot inicial, aguarda o número de segundos especificado e, depois, tira um segundo snapshot. A função compara os dois snapshots e retorna a diferença. Essa diferença representa a atividade da instância para esse intervalo de tempo. Na instância de gravador, a função também exibe o número de transações confirmadas e TPS (transações por segundo). Essa função retorna informações no nível da instância e inclui todos os bancos de dados na instância. ## Exemplos Este exemplo mostra como criar a extensão aurora\$1stat\$1utils para poder usar a função aurora\$1wait\$1report. ``` => CREATE extension aurora_stat_utils; CREATE EXTENSION ``` Este exemplo mostra como conferir o relatório de espera por 10 segundos. ``` => 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 ``` Este exemplo mostra como conferir o relatório de espera por 60 segundos. ``` => 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 parameters Você gerencia o cluster de bancos de dados Amazon Aurora da mesma maneira que gerencia outras instâncias de banco de dados do Amazon RDS, usando parâmetros em um grupo de parâmetros de banco de dados. No entanto, o Amazon Aurora difere do Amazon RDS porque um cluster de bancos de dados Aurora tem várias instâncias de banco de dados. Dessa forma, alguns dos parâmetros que você usa para gerenciar seu cluster de bancos de dados Amazon Aurora se aplicam a todo o cluster, enquanto outros parâmetros se aplicam apenas a uma instância de banco de dados particular no cluster de banco de dados, como o seguinte: + **Grupo de parâmetros do cluster de banco de dados**: um grupo de parâmetros do cluster de banco de dados contém o conjunto de parâmetros de configuração do mecanismo que se aplicam em todo o cluster de bancos de dados Aurora. Por exemplo, o gerenciamento de cache de cluster é um recurso de um cluster de bancos de dados Aurora que é controlado pelo parâmetro `apg_ccm_enabled` que faz parte do grupo de parâmetros de cluster de banco de dados. O grupo de parâmetros do cluster de banco de dados também contém configurações padrão para o grupo de parâmetros de banco de dados das instâncias de banco de dados que compõem o cluster. + **Grupo de parâmetros de banco de dados**: um grupo de parâmetros de banco de dados é o conjunto de valores de configuração do mecanismo que se aplicam a uma instância de banco de dados específica desse tipo de mecanismo. Os grupos de parâmetros de banco de dados para o mecanismo de banco de dados do PostgreSQL são usados por uma instância de banco de dados do RDS para PostgreSQL e um cluster de bancos de dados do Aurora PostgreSQL. Essas definições de configuração aplicam-se a propriedades que podem variar entre as instâncias de banco de dados em um cluster do Aurora, como os tamanhos dos buffers de memória. Você gerencia parâmetros em nível de cluster em grupos de parâmetros de cluster de banco de dados. Você gerencia parâmetros em nível de instância em grupos de parâmetros de banco de dados. Você pode gerenciar parâmetros usando o console do Amazon RDS, a AWS CLI ou a API do Amazon RDS. Há comandos separados para gerenciar parâmetros no nível do cluster e parâmetros no nível da instância. + Para gerenciar parâmetros no nível do cluster em um grupo de parâmetros do cluster de banco de dados, use o comando [modify-db-cluster-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster-parameter-group.html) da AWS CLI. + Para gerenciar parâmetros no nível da instância em um grupo de parâmetros de banco de dados de uma instância de banco de dados em um cluster de banco de dados, use o comando [modify-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-parameter-group.html) da AWS CLI. Para saber mais sobre a AWS CLI, consulte [Usar a AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-using.html) no *Guia do usuário do AWS Command Line Interface*. Para obter mais informações sobre grupos de parâmetros, consulte [Grupos de parâmetros para Amazon Aurora](USER_WorkingWithParamGroups.md). ## Exibindo parâmetros de banco de dados e de cluster de bancos de dados Aurora PostgreSQL Você pode exibir todos os grupos de parâmetros padrão disponíveis para instâncias de banco de dados do RDS para PostgreSQL e para clusters de bancos de dados Aurora PostgreSQL no Console de gerenciamento da AWS. Os grupos de parâmetros padrão para todos os mecanismos de banco de dados e tipos e versões de cluster de banco de dados são listados para cada região da AWS. Todos os grupos de parâmetros personalizados também estão listados. Em vez de visualizar no Console de gerenciamento da AWS, você também pode listar parâmetros contidos em grupos de parâmetros de cluster de banco de dados e grupos de parâmetros de banco de dados usando a AWS CLI ou a API do Amazon RDS. Por exemplo, para listar os parâmetros em um grupo de parâmetros do cluster de banco de dados, use o comando da AWS CLI [describe-db-cluster-parameters](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-cluster-parameters.html). ``` aws rds describe-db-cluster-parameters --db-cluster-parameter-group-name default.aurora-postgresql12 ``` O comando retorna descrições JSON detalhadas de cada parâmetro. Para reduzir a quantidade de informações retornadas, você pode especificar o que deseja usando a opção `--query`. Por exemplo, você pode obter o nome do parâmetro, sua descrição e os valores permitidos para o grupo de parâmetro de cluster de banco de dados padrão do Aurora PostgreSQL 12 da seguinte forma: Para Linux, macOS ou 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}]' ``` Para 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}]" ``` Um grupo de parâmetros de cluster de bancos de dados Aurora inclui o grupo de parâmetros da instância de banco de dados e os valores padrão para um determinado mecanismo de banco de dados do Aurora Você pode obter a lista de parâmetros de banco de dados do mesmo grupo de parâmetros padrão do Aurora PostgreSQL usando o comando da AWS CLI [describe-db-parameters](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-parameters.html) como mostrado a seguir. Para Linux, macOS ou Unix: ``` aws rds describe-db-parameters --db-parameter-group-name default.aurora-postgresql12 \ --query 'Parameters[].[{ParameterName:ParameterName,Description:Description,ApplyType:ApplyType,AllowedValues:AllowedValues}]' ``` Para Windows: ``` aws rds describe-db-parameters --db-parameter-group-name default.aurora-postgresql12 ^ --query "Parameters[].[{ParameterName:ParameterName,Description:Description,ApplyType:ApplyType,AllowedValues:AllowedValues}]" ``` Os comandos anteriores retornam listas de parâmetros do cluster de banco de dados ou grupo de parâmetros de banco de dados com descrições e outros detalhes especificados na consulta. Veja a seguir uma resposta de exemplo. ``` [ [ { "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" } ],... ``` A seguir estão as tabelas que contêm valores para o parâmetro de cluster de banco de dados padrão e o parâmetro de banco de dados para o Aurora PostgreSQL versão 14. ## Parâmetros no nível do cluster do Aurora PostgreSQL É possível visualizar parâmetros no nível do cluster disponíveis para uma versão do Aurora PostgreSQL usando o Console de Gerenciamento da AWS, a AWS CLI ou a API do Amazon RDS. Para obter informações sobre como visualizar os parâmetros em grupos de parâmetros de cluster de banco de dados do Aurora PostgreSQL no console do RDS, consulte [Visualizar valores de parâmetros de um grupo de parâmetros de cluster de banco de dadosno Amazon Aurora](USER_WorkingWithParamGroups.ViewingCluster.md). Alguns parâmetros no nível de cluster não estão disponíveis em todas as versões e alguns estão sendo descontinuados. Para obter informações sobre como visualizar os parâmetros de uma versão específica do Aurora PostgreSQL, consulte [Exibindo parâmetros de banco de dados e de cluster de bancos de dados Aurora PostgreSQL](#AuroraPostgreSQL.Reference.ParameterGroups-viewing-parameters). Por exemplo, a tabela a seguir lista os parâmetros disponíveis no grupo de parâmetros de cluster de banco de dados padrão para o Aurora PostgreSQL versão 14. Se você criar um cluster de bancos de dados Aurora PostgreSQL sem especificar seu próprio grupo de parâmetros de banco de dados personalizado, seu cluster de banco de dados será criado usando o grupo de parâmetros de cluster de banco de dados padrão do Aurora para a versão escolhida, como `default.aurora-postgresql14`, `default.aurora-postgresql13` e assim por diante. Para obter uma lista dos parâmetros de instância de banco de dados para o mesmo grupo de parâmetros padrão do cluster de banco de dados, consulte [Parâmetros no nível da instância do Aurora PostgreSQL](#AuroraPostgreSQL.Reference.Parameters.Instance). | Nome do parâmetro | Descrição | Padrão | | --- | --- | --- | | ansi\$1constraint\$1trigger\$1ordering | Altere a ordem de disparo dos acionadores de restrição para ser compatível com o padrão ANSI SQL. | – | | ansi\$1force\$1foreign\$1key\$1checks | Certifique-se de que ações referenciais, como exclusão em cascata ou atualização em cascata, sempre ocorrerão independentemente dos vários contextos de acionadores existentes para a ação. | – | | ansi\$1qualified\$1update\$1set\$1target | Suporta qualificadores de tabela e esquema em UPDATE... Instruções SET. | – | | apg\$1ccm\$1enabled | Habilita ou desabilita o gerenciamento de cache de cluster para o cluster. | – | | apg\$1enable\$1batch\$1mode\$1function\$1execution | Permite que as funções em modo em lote processem conjuntos de linhas de cada vez. | – | | apg\$1enable\$1correlated\$1any\$1transform | Permite que o planejador transforme ANY Sublink correlacionado (subconsulta IN/NOT IN) para JOIN quando possível. | – | | apg\$1enable\$1function\$1migration | Permite que o planejador migre funções escalares elegíveis para a cláusula FROM. | – | | apg\$1enable\$1not\$1in\$1transform | Permite que o planejador transforme a subconsulta NOT IN em ANTI JOIN quando possível. | – | | apg\$1enable\$1remove\$1redundant\$1inner\$1joins | Permite que o planejador remova junções internas redundantes. | – | | apg\$1enable\$1semijoin\$1push\$1down | Permite o uso de filtros de semijunção para junções de hash. | – | | apg\$1plan\$1mgmt.capture\$1plan\$1baselines | Modo de linha de base do plano de captura. manual: habilita a captura de plano para qualquer instrução SQL, desativado: desabilita captura de plano, automático: habilita a captura de plano para instruções em pg\$1stat\$1statement que atendam aos critérios de elegibilidade. | desligar | | apg\$1plan\$1mgmt.max\$1databases | Define o número máximo de bancos de dados que podem gerenciar consultas usando apg\$1plan\$1mgmt. | 10 | | apg\$1plan\$1mgmt.max\$1plans | Define o número máximo de planos que podem ser armazenados em cache por apg\$1plan\$1mgmt. | 10000 | | apg\$1plan\$1mgmt.plan\$1retention\$1period | Número máximo de dias desde que um plano foi last\$1used antes de um plano ser excluído automaticamente. | 32 | | apg\$1plan\$1mgmt.unapproved\$1plan\$1execution\$1threshold | Custo total estimado do plano abaixo do qual um plano não aprovado será executado. | 0 | | apg\$1plan\$1mgmt.use\$1plan\$1baselines | Usa somente planos aprovados ou fixos para instruções gerenciadas. | false | | application\$1name | Define o nome da aplicação a ser informada em estatísticas e logs. | – | | array\$1nulls | Permite entrada de elementos NULL em arrays. | – | | aurora\$1compute\$1plan\$1id | Monitora planos de execução de consultas para detectar planos de execução que contribuem com a carga de banco de dados atual e para monitorar as estatísticas de desempenho de planos de execução ao longo do tempo. Consulte mais informações em [Monitoring query execution plans for Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraPostgreSQL.Monitoring.Query.Plans.html). | ativado | | authentication\$1timeout | (s) Define o tempo máximo permitido para concluir a autenticação de cliente. | – | | auto\$1explain.log\$1analyze | Usa EXPLAIN ANALYZE para registro em log de planos. | – | | auto\$1explain.log\$1buffers | Uso de buffers de log. | – | | auto\$1explain.log\$1format | Formato EXPLAIN a ser usado para registro em log de planos. | – | | auto\$1explain.log\$1min\$1duration | Define o tempo de execução mínimo acima do qual as instruções serão registradas em log. | – | | auto\$1explain.log\$1nested\$1statements | Registrar instruções aninhadas. | – | | auto\$1explain.log\$1timing | Coleta dados de tempo, não apenas contagens de linhas. | – | | auto\$1explain.log\$1triggers | Inclui estatísticas do acionador nos planos. | – | | auto\$1explain.log\$1verbose | Usa EXPLAIN VERBOSE para registro em log de planos. | – | | auto\$1explain.sample\$1rate | Fração de consultas a serem processadas. | – | | autovacuum | Inicia o subprocesso de autovacuum. | – | | autovacuum\$1analyze\$1scale\$1factor | Número de inserções, atualizações ou exclusões de tuplas anteriores à análise, como uma fração de reltuplas. | 0.05 | | autovacuum\$1analyze\$1threshold | Número mínimo de inserções, atualizações ou exclusões de tuplas antes da análise. | – | | autovacuum\$1freeze\$1max\$1age | Idade na qual o autovacuum de uma tabela deve ocorrer para evitar a conclusão do ID de transação. | – | | autovacuum\$1max\$1workers | Define o número máximo de processos de trabalho de autovacuum em execução simultaneamente. | GREATEST(DBInstanceClassMemory/64371566592,3) | | autovacuum\$1multixact\$1freeze\$1max\$1age | Idade multixact na qual o autovacuum de uma tabela deve ocorrer para evitar o wraparound multixact. | – | | autovacuum\$1naptime | (s) Tempo de suspensão entre execuções de autovacuum. | 5 | | autovacuum\$1vacuum\$1cost\$1delay | (ms) Atraso de custo de vacuum, em milissegundos, para autovacuum. | 5 | | autovacuum\$1vacuum\$1cost\$1limit | Valor do custo de vacuum disponível antes da suspensão, para autovacuum. | GREATEST(log(DBInstanceClassMemory/21474836480)\$1600,200) | | autovacuum\$1vacuum\$1insert\$1scale\$1factor | Número de inserções de tupla antes do vacuum como uma fração de reltuplas. | – | | autovacuum\$1vacuum\$1insert\$1threshold | Número mínimo de inserções de tupla antes do vacuum ou -1 para desabilitar os vacuums de inserção. | – | | autovacuum\$1vacuum\$1scale\$1factor | Número de atualizações ou exclusões de tuplas antes de vacuum, como uma fração de reltuplas. | 0.1 | | autovacuum\$1vacuum\$1threshold | Número mínimo de atualizações ou exclusões de tuplas antes do vacuum. | – | | autovacuum\$1work\$1mem | (kB) Define a memória máxima a ser usada por cada processo de operador de autovacuum. | GREATEST(DBInstanceClassMemory/32768,131072) | | babelfishpg\$1tds.default\$1server\$1name | O nome padrão do servidor Babelfish | Microsoft SQL Server | | babelfishpg\$1tds.listen\$1addresses | Define o nome do host ou um ou mais endereços IP para ouvir o TDS. | \$1 | | babelfishpg\$1tds.port | Define a porta TCP TDS na qual o servidor escuta. | 1433 | | babelfishpg\$1tds.tds\$1debug\$1log\$1level | Define o nível de registro em log no TDS, 0 desabilita o registro em log | 1 | | babelfishpg\$1tds.tds\$1default\$1numeric\$1precision | Define a precisão padrão do tipo numérico a ser enviada nos metadados da coluna TDS se o mecanismo não especificar uma. | 38 | | babelfishpg\$1tds.tds\$1default\$1numeric\$1scale | Define a escala padrão do tipo numérico a ser enviada nos metadados da coluna TDS se o mecanismo não especificar uma. | 8 | | babelfishpg\$1tds.tds\$1default\$1packet\$1size | Define o tamanho do pacote padrão para todos os clientes do SQL Server sendo conectados | 4096 | | babelfishpg\$1tds.tds\$1default\$1protocol\$1version | Define uma versão padrão do protocolo TDS para todos os clientes sendo conectados | DEFAULT | | babelfishpg\$1tds.tds\$1ssl\$1encrypt | Define a opção Criptografia SSL | 0 | | babelfishpg\$1tds.tds\$1ssl\$1max\$1protocol\$1version | Define a versão máxima do protocolo SSL/TLS a ser utilizada na sessão TDS. | TLSv1.2 | | babelfishpg\$1tds.tds\$1ssl\$1min\$1protocol\$1version | Define a versão mínima do protocolo SSL/TLS a ser utilizada na sessão TDS. | TLSv1.2 do Aurora PostgreSQL versão 16, TLSv1 para versões anteriores ao Aurora PostgreSQL versão 16 | | babelfishpg\$1tsql.default\$1locale | Localidade padrão a ser usada para agrupamentos criados por CREATE COLLATION. | en-US | | babelfishpg\$1tsql.migration\$1mode | Define se há suporte para vários bancos de dados de usuários. | multi-db do Aurora PostgreSQL versão 16, single-db para versões anteriores ao Aurora PostgreSQL versão 16 | | babelfishpg\$1tsql.server\$1collation\$1name | Nome do agrupamento de servidores padrão | sql\$1latin1\$1general\$1cp1\$1ci\$1as | | babelfishpg\$1tsql.version | Define a saída da variável @@VERSION. | padrão | | backend\$1flush\$1after | (8Kb) Número de páginas após as quais as gravações executadas anteriormente são liberadas para o disco. | – | | backslash\$1quote | Define se \$1\$1 é permitido em literais de string. | – | | backtrace\$1functions | Registre o backtrace em busca de erros nessas funções. | – | | bytea\$1output | Define o formato da saída para bytes. | – | | check\$1function\$1bodies | Verifica corpos de funções durante CREATE FUNCTION. | – | | client\$1connection\$1check\$1interval | Define o intervalo de tempo entre as verificações de desconexão durante a execução de consultas. | – | | client\$1encoding | Define a codificação do conjunto de caracteres do cliente. | UTF8 | | client\$1min\$1messages | Define os níveis de mensagem enviados ao cliente. | – | | compute\$1query\$1id | Calcula identificadores de consulta. | auto | | config\$1file | Define o arquivo de configuração principal dos servidores. | /rdsdbdata/config/postgresql.conf | | constraint\$1exclusion | Permite que o planejador use restrições para otimizar consultas. | – | | cpu\$1index\$1tuple\$1cost | Define a estimativa do planejador sobre o custo do processamento de cada entrada de índice durante uma verificação de índice. | – | | cpu\$1operator\$1cost | Define a estimativa do planejador sobre o custo do processamento de cada operador ou chamada de função. | – | | cpu\$1tuple\$1cost | Define a estimativa do planejador sobre o custo do processamento de cada tupla (linha). | – | | cron.database\$1name | Define o banco de dados para armazenar tabelas de metadados pg\$1cron | postgres | | cron.log\$1run | Registra todos os trabalhos executados na tabela job\$1run\$1details | ativado | | cron.log\$1statement | Registre todas as instruções cron antes da execução. | desligar | | cron.max\$1running\$1jobs | O número máximo de trabalhos que podem ser executados simultaneamente. | 5 | | cron.use\$1background\$1workers | Habilita operadores em segundo plano para pg\$1cron | ativado | | cursor\$1tuple\$1fraction | Define a estimativa do planejador sobre a fração de linhas de um cursor que serão recuperadas. | – | | data\$1directory | Define o diretório de dados do servidor. | /rdsdbdata/db | | datestyle | Define o formato de exibição de valores de data e hora. | – | | db\$1user\$1namespace | Ativa nomes de usuário por banco de dados. | – | | deadlock\$1timeout | (ms) Define o tempo de espera em um bloqueio antes de verificar a existência de um deadlock. | – | | debug\$1pretty\$1print | Recua exibições de árvores de análise e plano. | – | | debug\$1print\$1parse | Registra a árvore de análise de cada consulta. | – | | debug\$1print\$1plan | Registra o plano de execução de cada consulta. | – | | debug\$1print\$1rewritten | Registra a árvore de análise regravada de cada consulta. | – | | default\$1statistics\$1target | Define o destino de estatísticas padrão. | – | | default\$1tablespace | Define o espaço de tabela padrão no qual criar tabelas e índices. | – | | default\$1toast\$1compression | Define o método de compactação padrão para valores compactáveis. | – | | default\$1transaction\$1deferrable | Define o status padrão postergável de novas transações. | – | | default\$1transaction\$1isolation | Define o nível de isolamento de transação de cada nova transação. | – | | default\$1transaction\$1read\$1only | Define o status padrão somente leitura de novas transações. | – | | effective\$1cache\$1size | (8kB) Define a pressuposição do planejador sobre o tamanho do cache de disco. | SUM(DBInstanceClassMemory/12038,-50003) | | effective\$1io\$1concurrency | Número de solicitações simultâneas que podem ser manipuladas de forma eficiente pelo subsistema de disco. | – | | enable\$1async\$1append | Habilita o uso do planejador de planos de anexação assíncronos. | – | | enable\$1bitmapscan | Habilita o uso do planejador de planos de verificação de bitmap. | – | | enable\$1gathermerge | Habilita o uso do planejador de planos de junção de mesclagem. | – | | enable\$1hashagg | Habilita o uso do planejador de planos de agregação em hash. | – | | enable\$1hashjoin | Habilita o uso do planejador de planos de junção hash. | – | | enable\$1incremental\$1sort | Habilita o uso do planejador de etapas de classificação incremental. | – | | enable\$1indexonlyscan | Habilita o uso do planejador de planos de verificação somente de índice. | – | | enable\$1indexscan | Habilita o uso do planejador de planos de verificação de índice. | – | | enable\$1material | Habilita o uso do planejador da materialização. | – | | enable\$1memoize | Habilita o uso do planejador da memoização | – | | enable\$1mergejoin | Habilita o uso do planejador de planos de junção de mesclagem. | – | | enable\$1nestloop | Habilita o uso do planejador de planos de junção de loop aninhado. | – | | enable\$1parallel\$1append | Habilita o uso do planejador de planos de anexação paralelos. | – | | enable\$1parallel\$1hash | Habilita o uso do planejador de planos de hash paralelos. | – | | enable\$1partition\$1pruning | Habilita a remoção de partição em tempo de planejamento e tempo de execução. | – | | enable\$1partitionwise\$1aggregate | Habilita agregação e agrupamento por partição. | – | | enable\$1partitionwise\$1join | Habilita a junção por partição. | – | | enable\$1seqscan | Habilita o uso do planejador de planos de verificação sequencial. | – | | enable\$1sort | Habilita o uso do planejador de etapas de classificação explícitas. | – | | enable\$1tidscan | Habilita o uso do planejador de planos de verificação TID. | – | | escape\$1string\$1warning | Avisa sobre escapes de barra invertida (\$1) em literais de string comuns. | – | | exit\$1on\$1error | Encerra a sessão em qualquer erro. | – | | extra\$1float\$1digits | Define o número de dígitos exibidos para valores de ponto flutuante. | – | | force\$1parallel\$1mode | Força o uso de instalações de consulta paralela. | – | | from\$1collapse\$1limit | Define o tamanho da lista FROM além do qual subconsultas não são recolhidas. | – | | geqo | Permite a otimização de consultas genéticas. | – | | geqo\$1effort | GEQO: esforço é usado para definir o padrão para outros parâmetros GEQO. | – | | geqo\$1generations | GEQO: número de iterações do algoritmo. | – | | geqo\$1pool\$1size | GEQO: número de indivíduos na população. | – | | geqo\$1seed | GEQO: propagação para seleção de caminho aleatório. | – | | geqo\$1selection\$1bias | GEQO: pressão seletiva dentro da população. | – | | geqo\$1threshold | Define o limite de itens FROM além do qual o GEQO é usado. | – | | gin\$1fuzzy\$1search\$1limit | Define o resultado máximo permitido para pesquisa exata por GIN. | – | | gin\$1pending\$1list\$1limit | (kB) Define o tamanho máximo da lista pendente para o índice GIN. | – | | hash\$1mem\$1multiplier | Múltiplos de work\$1mem para usar em tabelas de hash. | – | | hba\$1file | Define o arquivo de configuração do hba dos servidores. | /rdsdbdata/config/pg\$1hba.conf | | hot\$1standby\$1feedback | Permite feedback de um standby a quente para o primário que evitará conflitos de consulta. | ativado | | huge\$1pages | Reduz a sobrecarga quando uma instância de banco de dados está trabalhando com grandes blocos contíguos de memória, como os usados por buffers compartilhados. Ele é ativado por padrão para todas as classes de instância de banco de dados, exceto as classes de instância t3.medium, db.t3.large, db.t4g.medium e db.t4g.large. | ativado | | ident\$1file | Define o arquivo de configuração de ident dos servidores. | /rdsdbdata/config/pg\$1ident.conf | | idle\$1in\$1transaction\$1session\$1timeout | (ms) Define a duração máxima permitida de qualquer transação inativa. | 86400000 | | idle\$1session\$1timeout | Encerra qualquer sessão que tenha ficado ociosa (ou seja, aguardando uma consulta do cliente), mas não em uma transação aberta, por um tempo maior que o especificado. | – | | intervalstyle | Define o formato de exibição para valores de intervalo. | – | | join\$1collapse\$1limit | Define o tamanho da lista FROM além do qual constructos JOIN não são nivelados. | – | | krb\$1caseins\$1users | Define se os nomes de usuário da GSSAPI (Generic Security Service API) devem ser tratados sem distinção entre maiúsculas e minúsculas (true) ou não. Por padrão, esse parâmetro é definido como false, então o Kerberos espera que os nomes de usuário diferenciem maiúsculas e minúsculas. Para obter mais informações, consulte [GSSAPI Authentication](https://www.postgresql.org/docs/current/gssapi-auth.html) (Autenticação da GSSAPI) na documentação do PostgreSQL. | false | | lc\$1messages | Define o idioma em que as mensagens são exibidas. | – | | lc\$1monetary | Define a localidade para a formatação de valores monetários. | – | | lc\$1numeric | Define a localidade para a formatação de números. | – | | lc\$1time | Define a localidade para a formatação de valores de data e hora. | – | | listen\$1addresses | Define o nome do host ou os endereços IP para escutar. | \$1 | | lo\$1compat\$1privileges | Habilita o modo de compatibilidade com versões anteriores para verificações de privilégios em objetos grandes. | 0 | | log\$1autovacuum\$1min\$1duration | (ms) Define o tempo de execução mínimo acima do qual as ações de autovacuum serão registradas em log. | 10000 | | log\$1connections | Registra cada conexão bem-sucedida. | – | | log\$1destination | Define o destino para a saída de log do servidor. | stderr | | log\$1directory | Define o diretório de destino para arquivos de log. | /rdsdbdata/log/error | | log\$1disconnections | Registra o fim de uma sessão, incluindo a duração. | – | | log\$1duration | Registra a duração de cada instrução SQL concluída. | – | | log\$1error\$1verbosity | Define a verbosidade das mensagens registradas. | – | | log\$1executor\$1stats | Grava estatísticas de desempenho do executor no log do servidor. | – | | log\$1file\$1mode | Define as permissões de arquivo para arquivos de log. | 0644 | | log\$1filename | Define o padrão de nome de arquivo para arquivos de log. | postgresql.log.%Y-%m-%d-%H%M | | logging\$1collector | Inicia um subprocesso para capturar a saída stderr e/ou csvlogs em arquivos de log. | 1 | | log\$1hostname | Registra o nome do host nos logs de conexão. | 0 | | logical\$1decoding\$1work\$1mem | (kB) Essa quantidade de memória pode ser usada por cada buffer de reordenamento interno antes de espalhar para o disco. | – | | log\$1line\$1prefix | Controla informações prefixadas para cada linha de log. | %t:%r:%u@%d:%p]: | | log\$1lock\$1waits | Registra esperas de bloqueio longas. | – | | log\$1min\$1duration\$1sample | (ms) Define o tempo de execução mínimo acima do qual as instruções serão registradas em log. A amostragem é determinada por log\$1statement\$1sample\$1rate. | – | | log\$1min\$1duration\$1statement | (ms) Define o tempo de execução mínimo acima do qual as instruções serão registradas em log. | – | | log\$1min\$1error\$1statement | Faz com que todas as instruções que geram um erro igual ou acima desse nível sejam registradas em log. | – | | log\$1min\$1messages | Define os níveis de mensagem registrados. | – | | log\$1parameter\$1max\$1length | (B) Quando as instruções de registro em log limitam os valores de parâmetros registrados em log aos primeiros N bytes. | – | | log\$1parameter\$1max\$1length\$1on\$1error | (B) Quando o relato de um erro limita os valores de parâmetros registrados em log aos primeiros N bytes. | – | | log\$1parser\$1stats | Grava estatísticas de desempenho do analisador no log do servidor. | – | | log\$1planner\$1stats | Grava estatísticas de desempenho do planejador no log do servidor. | – | | log\$1replication\$1commands | Registra cada comando de replicação. | – | | log\$1rotation\$1age | (min) A alternância automática de arquivos de log ocorrerá depois de N minutos. | 60 | | log\$1rotation\$1size | (kB) A alternância automática de arquivos de log ocorrerá depois de N kilobytes. | 100000 | | log\$1statement | Define o tipo de instruções registradas. | – | | log\$1statement\$1sample\$1rate | Fração de instruções que excedem log\$1min\$1duration\$1sample a serem registradas em log. | – | | log\$1statement\$1stats | Grava estatísticas de desempenho cumulativas no log do servidor. | – | | log\$1temp\$1files | (kB) Registra o uso de arquivos temporários maiores do que esse número de kilobytes. | – | | log\$1timezone | Define o fuso horário a ser usado em mensagens de log. | UTC | | log\$1transaction\$1sample\$1rate | Define a fração de transações para registrar novas transações. | – | | log\$1truncate\$1on\$1rotation | Trunca os arquivos de log existentes com o mesmo nome durante a alternância do log. | 0 | | maintenance\$1io\$1concurrency | Uma variante de effective\$1io\$1concurrency usada para trabalhos de manutenção. | 1 | | maintenance\$1work\$1mem | (kB) Define a memória máxima a ser usada para operações de manutenção. | GREATEST(DBInstanceClassMemory/63963136\$11024,65536) | | max\$1connections | Define o número máximo de conexões simultâneas. | LEAST(DBInstanceClassMemory/9531392,5000) | | max\$1files\$1per\$1process | Define o número máximo de arquivos abertos simultaneamente para cada processo do servidor. | – | | max\$1locks\$1per\$1transaction | Define o número máximo de bloqueios por transação. | 64 | | max\$1logical\$1replication\$1workers | Número máximo de processos do operador de replicação lógica. | – | | max\$1parallel\$1maintenance\$1workers | Define o número máximo de processos em paralelo por operação de manutenção. | – | | max\$1parallel\$1workers | Define o número máximo de operadores em paralelo que podem estar ativos de uma só vez. | GREATEST(\$1DBInstanceVCPU/2,8) | | max\$1parallel\$1workers\$1per\$1gather | Define o número máximo de processos em paralelo por nó do executor. | – | | max\$1pred\$1locks\$1per\$1page | Define o número máximo de tuplas bloqueadas por predicado por página. | – | | max\$1pred\$1locks\$1per\$1relation | Define o número máximo de páginas e tuplas bloqueadas por predicado por relação. | – | | max\$1pred\$1locks\$1per\$1transaction | Define o número máximo de bloqueios de predicado por transação. | – | | max\$1prepared\$1transactions | Define o número máximo de transações simultaneamente preparadas. | 0 | | max\$1replication\$1slots | Define o número máximo de slots de replicação que o servidor pode suportar. | 20 | | max\$1slot\$1wal\$1keep\$1size | (MB) Os slots de replicação serão marcados como falhos e segmentos liberados para exclusão ou reciclagem se esse espaço for ocupado pelo WAL no disco. | – | | max\$1stack\$1depth | (kB) Define a profundidade máxima da pilha, em kilobytes. | 6144 | | max\$1standby\$1streaming\$1delay | (ms) Define o atraso máximo antes de cancelar consultas quando um servidor em standby a quente está processando dados do WAL em transmissão. | 14000 | | max\$1sync\$1workers\$1per\$1subscription | Número máximo de operadores de sincronização por assinatura | 2 | | max\$1wal\$1senders | Define o número máximo de processos do remetente WAL em execução simultânea. | 10 | | max\$1worker\$1processes | Define o número máximo de processos de operadores simultâneos. | GREATEST(\$1DBInstanceVCPU\$12,8) | | min\$1dynamic\$1shared\$1memory | (MB) Quantidade de memória compartilhada dinâmica reservada na inicialização. | – | | min\$1parallel\$1index\$1scan\$1size | (8kB) Define a quantidade mínima de dados de índice para uma varredura paralela. | – | | min\$1parallel\$1table\$1scan\$1size | (8kB) Define a quantidade mínima de dados de tabela para uma varredura paralela. | – | | old\$1snapshot\$1threshold | (min) O tempo antes de um snapshot ser muito antigo para ler as páginas alteradas depois que o snapshot foi tirado. | – | | orafce.nls\$1date\$1format | Emula o comportamento de saída de data oracles. | – | | orafce.timezone | Especifique o fuso horário utilizado para a função sysdate. | – | | parallel\$1leader\$1participation | Controla se Reunir e Reunir mesclagem também executam subplanos. | – | | parallel\$1setup\$1cost | Define a estimativa dos planejadores do custo de inicialização de processos de operadores para consulta paralela. | – | | parallel\$1tuple\$1cost | Define a estimativa dos planejadores do custo de passar cada tupla (linha) do operador para o backend primário. | – | | password\$1encryption | Criptografa senhas. | – | | pgaudit.log | Especifica quais classes de instruções serão registradas pelo registro em log de auditoria de sessão. | – | | pgaudit.log\$1catalog | Especifica que o registro em log da sessão deve ser habilitado no caso em que todas as relações em uma instrução estão em pg\$1catalog. | – | | pgaudit.log\$1level | Especifica o nível de log que será usado para entradas de log. | – | | pgaudit.log\$1parameter | Especifica que o registro em log de auditoria deve incluir os parâmetros que foram passados com a instrução. | – | | pgaudit.log\$1relation | Especifica se o registro em log de auditoria de sessão deve criar uma entrada de log separada para cada relação (TABLE, VIEW etc.) referenciada em uma instrução SELECT ou DML. | – | | pgaudit.log\$1statement\$1once | Especifica se o registro incluirá o texto e os parâmetros da instrução com a primeira entrada de log para uma combinação de instrução/subinstrução ou com cada entrada. | – | | pgaudit.role | Especifica a função primária a ser usada para o registro em log de auditoria de objetos. | – | | pg\$1bigm.enable\$1recheck | Ele especifica se deseja executar a Reverificação, que é um processo interno de pesquisa de texto completo. | ativado | | pg\$1bigm.gin\$1key\$1limit | Ele especifica o número máximo de 2 gramas da palavra-chave de pesquisa a ser usada para pesquisa de texto completo. | 0 | | pg\$1bigm.last\$1update | Ele relata a última data atualizada do módulo pg\$1bigm. | 2013.11.22 | | pg\$1bigm.similarity\$1limit | Ele especifica o limite mínimo usado pela pesquisa por similaridade. | 0.3 | | pg\$1hint\$1plan.debug\$1print | Registra os resultados da análise de dicas. | – | | pg\$1hint\$1plan.enable\$1hint | Força o planejador a usar planos especificados no comentário de dica anterior à consulta. | – | | pg\$1hint\$1plan.enable\$1hint\$1table | Força o planejador a não receber dicas usando pesquisas de tabela. | – | | pg\$1hint\$1plan.message\$1level | Nível da mensagem de mensagens de depuração. | – | | pg\$1hint\$1plan.parse\$1messages | Nível de mensagem de erros de análise. | – | | pglogical.batch\$1inserts | Inserções em lote, se possível | – | | pglogical.conflict\$1log\$1level | Define o nível de log usado para registrar em log conflitos resolvidos. | – | | pglogical.conflict\$1resolution | Define o método usado para resolução de conflitos para conflitos resolvíveis. | – | | pglogical.extra\$1connection\$1options | opções de conexão para adicionar a todas as conexões de nó de pares | – | | pglogical.synchronous\$1commit | Valor de confirmação síncrona específica do pglogical | – | | pglogical.use\$1spi | Usa SPI em vez de API de baixo nível para aplicar alterações | – | | pgtle.clientauth\$1databases\$1to\$1skip | Lista de bancos de dados a serem ignorados para o recurso clientauth. | – | | pgtle.clientauth\$1db\$1name | Controla qual banco de dados é usado para o recurso clientauth. | – | | pgtle.clientauth\$1num\$1parallel\$1workers | Número de operadores em segundo plano usados para o recurso clientauth. | – | | pgtle.clientauth\$1users\$1to\$1skip | Lista de usuários a serem ignorados para o recurso clientauth. | – | | pgtle.enable\$1clientauth | Ativa o recurso clientauth. | – | | pgtle.passcheck\$1db\$1name | Define qual banco de dados é usado para o recurso de verificação de acesso em todo o cluster. | – | | pg\$1prewarm.autoprewarm | Inicia o trabalhador de reaquecimento automático. | – | | pg\$1prewarm.autoprewarm\$1interval | Define o intervalo entre despejos de buffers compartilhados | – | | pg\$1similarity.block\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.block\$1threshold | Define o limite usado pela função de similaridade de bloco. | – | | pg\$1similarity.block\$1tokenizer | Define o tokenizador para a função de similaridade de bloco. | – | | pg\$1similarity.cosine\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.cosine\$1threshold | Define o limite usado pela função de similaridade de cosseno. | – | | pg\$1similarity.cosine\$1tokenizer | Define o tokeniziador para a função de similaridade de cosseno. | – | | pg\$1similarity.dice\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.dice\$1threshold | Define o limite usado pela medida de similaridade de dados. | – | | pg\$1similarity.dice\$1tokenizer | Define o tokenizador para a medida de similaridade de dados. | – | | pg\$1similarity.euclidean\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.euclidean\$1threshold | Define o limite usado pela medida de similaridade euclidiana. | – | | pg\$1similarity.euclidean\$1tokenizer | Define o tokenizador para a medida de similaridade euclidiana. | – | | pg\$1similarity.hamming\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.hamming\$1threshold | Define o limite usado pela métrica de similaridade de bloco. | – | | pg\$1similarity.jaccard\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.jaccard\$1threshold | Define o limite usado pela medida de similaridade Jaccard. | – | | pg\$1similarity.jaccard\$1tokenizer | Define o tokenizador para a medida de similaridade Jaccard. | – | | pg\$1similarity.jaro\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.jaro\$1threshold | Define o limite usado pela medida de similaridade Jaro. | – | | pg\$1similarity.jarowinkler\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.jarowinkler\$1threshold | Define o limite usado pela medida de similaridade Jarowinkler. | – | | pg\$1similarity.levenshtein\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.levenshtein\$1threshold | Define o limite usado pela medida de similaridade Levenshtein. | – | | pg\$1similarity.matching\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.matching\$1threshold | Define o limite usado pela medida de similaridade de Coeficiente de correspondência. | – | | pg\$1similarity.matching\$1tokenizer | Define o tokenizador para a medida de similaridade de Coeficiente de correspondência. | – | | pg\$1similarity.mongeelkan\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.mongeelkan\$1threshold | Define o limite usado pela medida de similaridade Monge-Elkan. | – | | pg\$1similarity.mongeelkan\$1tokenizer | Define o tokenizador para a medida de similaridade Monge-Elkan. | – | | pg\$1similarity.nw\$1gap\$1penalty | Define a penalidade de lacuna usada pela medida de similaridade Needleman-Wunsch. | – | | pg\$1similarity.nw\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.nw\$1threshold | Define o limite usado pela medida de similaridade Needleman-Wunsch. | – | | pg\$1similarity.overlap\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.overlap\$1threshold | Define o limite usado pela medida de similaridade do Coeficiente de sobreposição. | – | | pg\$1similarity.overlap\$1tokenizer | Define o tokenizador para a medida de similaridade de coeficientes de sobreposição. | – | | pg\$1similarity.qgram\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.qgram\$1threshold | Define o limite usado pela medida de similaridade Q-Gram. | – | | pg\$1similarity.qgram\$1tokenizer | Define o tokenizador para a medida Q-Gram. | – | | pg\$1similarity.swg\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.swg\$1threshold | Define o limite usado pela medida de similaridade Smith-Waterman-Gotoh. | – | | pg\$1similarity.sw\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.sw\$1threshold | Define o limite usado pela medida de similaridade Smith-Waterman. | – | | pg\$1stat\$1statements.max | Define o número máximo de instruções rastreadas por pg\$1stat\$1statements. | – | | pg\$1stat\$1statements.save | Salva as estatísticas pg\$1stat\$1statements em todas os desligamentos do servidor. | – | | pg\$1stat\$1statements.track | Seleciona quais instruções são rastreadas por pg\$1stat\$1statements. | – | | pg\$1stat\$1statements.track\$1planning | Seleciona se a duração do planejamento é rastreada por pg\$1stat\$1statements. | – | | pg\$1stat\$1statements.track\$1utility | Seleciona se os comandos do utilitário são rastreados por pg\$1stat\$1statements. | – | | plan\$1cache\$1mode | Controla a seleção do planejador de plano personalizado ou genérico. | – | | porta | Define a porta TCP na qual o servidor escuta. | EndPointPort | | postgis.gdal\$1enabled\$1drivers | Habilita ou desabilita drivers GDAL usados com PostGIS no Postgres 9.3.5 e posteriores. | ENABLE\$1ALL | | quote\$1all\$1identifiers | Ao gerar fragmentos SQL, cita todos os identificadores. | – | | random\$1page\$1cost | Define a estimativa do planejador sobre o custo de uma página de disco não sequencialmente buscada. | – | | rdkit.dice\$1threshold | Limite inferior de similaridade de dados. Moléculas com similaridade menor que o limite não são semelhantes pela operação \$1. | – | | rdkit.do\$1chiral\$1sss | A estereoquímica deve ser levada em consideração na correspondência de subestruturas. Se falsa, nenhuma informação estereoquímica é usada em correspondências de subestrutura. | – | | rdkit.tanimoto\$1threshold | Limite inferior de similaridade de Tanimoto. Moléculas com similaridade menor que o limite não são semelhantes pela operação %. | – | | rds.accepted\$1password\$1auth\$1method | Forçar a autenticação para conexões com senha armazenada localmente. | md5\$1scram | | rds.adaptive\$1autovacuum | Parâmetro RDS para habilitar/desabilitar o autovacuum adaptativo. | 1 | | rds.babelfish\$1status | Parâmetro RDS para habilitar/desabilitar o Babelfish for Aurora PostgreSQL. | desligar | | rds.enable\$1plan\$1management | Habilita ou desabilita a extensão apg\$1plan\$1mgmt. | 0 | | rds.extensions | Lista de extensões fornecidas pelo 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 | Consulta mensagens de log para ações de usuário administrador do RDS em bancos de dados de clientes. | – | | rds.force\$1autovacuum\$1logging\$1level | Consulta mensagens de log relacionadas às operações de autovacuum. | WARNING | | rds.force\$1ssl | Força conexões SSL. | 0 | | rds.global\$1db\$1rpo | (s) Limite do objetivo do ponto de recuperação em segundos que bloqueia confirmações do usuário quando ele é violado. Esse parâmetro é destinado aos bancos de dados globais baseados no Aurora PostgreSQL. Para um banco de dados não global, deixe-o com o valor padrão. Para obter mais informações sobre como usar esse parâmetro, consulte [Gerenciamento de RPOs para bancos de dados globais baseados em Aurora PostgreSQL–](aurora-global-database-disaster-recovery.md#aurora-global-database-manage-recovery). | – | | rds.logical\$1replication | Permite decodificação lógica. | 0 | | rds.logically\$1replicate\$1unlogged\$1tables | As tabelas não registradas em log são replicadas logicamente. | 1 | | rds.log\$1retention\$1period | O Amazon RDS excluirá o log do PostgreSQL com mais de N minutos. | 4320 | | rds.pg\$1stat\$1ramdisk\$1size | Tamanho das estatísticas ramdisk em MB. Um valor diferente de zero configurará o ramdisk. Esse parâmetro só está disponível no Aurora PostgreSQL 14 e versões anteriores. | 0 | | rds.rds\$1superuser\$1reserved\$1connections | Define o número de slots de conexão reservados para rds\$1superusers. Esse parâmetro só está disponível nas versões 15 e posterior. Para ter mais informações, consulte [reserved connections](https://www.postgresql.org/docs/current/runtime-config-connection.html#GUC-RESERVED-CONNECTIONS) na documentação do PostgreSQL. | 2 | | rds.restrict\$1password\$1commands | Restringe comandos relacionados a senha a membros do rds\$1password | – | | rds.superuser\$1variables | Lista de variáveis somente superusuário para as quais elevamos as instruções de modificação rds\$1superuser. | session\$1replication\$1role | | recovery\$1init\$1sync\$1method | Define o método para sincronizar o diretório de dados antes da recuperação de falhas. | syncfs | | remove\$1temp\$1files\$1after\$1crash | Remove arquivos temporários após falha de backend. | 0 | | restart\$1after\$1crash | Reinicializa o servidor após falha de backend. | – | | row\$1security | Habilita a segurança de linha. | – | | search\$1path | Define a ordem de pesquisa do esquema de nomes que não são qualificados para esquema. | – | | seq\$1page\$1cost | Define a estimativa do planejador sobre o custo de uma página de disco sequencialmente buscada. | – | | session\$1replication\$1role | Define o comportamento de sessões para disparadores e regras de regravação. | – | | shared\$1buffers | (8kB) Define o número de buffers de memória compartilhada usados pelo servidor. | SUM(DBInstanceClassMemory/12038,-50003) | | shared\$1preload\$1libraries | Lista bibliotecas compartilhadas para pré-carregar no servidor. | pg\$1stat\$1statements | | ssl | Habilita conexões SSL. | 1 | | ssl\$1ca\$1file | Localização do arquivo de autoridade do servidor SSL. | /rdsdbdata/rds-metadata/ca-cert.pem | | ssl\$1cert\$1file | Localização do arquivo de certificado do servidor SSL. | /rdsdbdata/rds-metadata/server-cert.pem | | ssl\$1ciphers | Define a lista de criptografias TLS permitidas em conexões seguras. | – | | ssl\$1crl\$1dir | Localização do diretório da lista de revogação de certificados SSL. | /rdsdbdata/rds-metadata/ssl\$1crl\$1dir/ | | ssl\$1key\$1file | Localização do arquivo de chave privada do servidor SSL | /rdsdbdata/rds-metadata/server-key.pem | | ssl\$1max\$1protocol\$1version | Define a versão máxima do protocolo SSL/TLS permitida | – | | ssl\$1min\$1protocol\$1version | Define a versão mínima do protocolo SSL/TLS permitida | TLSv1.2 | | standard\$1conforming\$1strings | Faz com que strings ... tratem barras invertidas literalmente. | – | | statement\$1timeout | (ms) Define a duração máxima permitida de qualquer instrução. | – | | stats\$1temp\$1directory | Grava arquivos de estatísticas temporárias no diretório especificado. | /rdsdbdata/db/pg\$1stat\$1tmp | | superuser\$1reserved\$1connections | Define o número de slots de conexão reservados para superusuários. | 3 | | synchronize\$1seqscans | Habilita varreduras sequenciais sincronizadas. | – | | synchronous\$1commit | Define o nível de sincronização de transações atual. | ativado | | tcp\$1keepalives\$1count | Número máximo de retransmissões de keepalives TCP. | – | | tcp\$1keepalives\$1idle | (s) Tempo entre a emissão de keepalives TCP. | – | | tcp\$1keepalives\$1interval | (s) Tempo entre retransmissões de keepalives TCP. | – | | temp\$1buffers | (8kB) Define o número máximo de buffers temporários usado por cada sessão. | – | | temp\$1file\$1limit | Restringe a quantidade total de espaço em disco em kilobytes que um determinado processo PostgreSQL pode usar para arquivos temporários, excluindo o espaço usado para tabelas temporárias explícitas | -1 | | temp\$1tablespaces | Define os espaços de tabela a serem usados para tabelas temporárias e arquivos de classificação. | – | | timezone | Define o fuso horário para exibir e interpretar carimbos de data/hora. | UTC | | track\$1activities | Coleta informações sobre a execução de comandos. | – | | track\$1activity\$1query\$1size | Define o tamanho reservado para pg\$1stat\$1activity.current\$1query, em bytes. | 4096 | | track\$1commit\$1timestamp | Coleta o tempo de confirmação da transação. | – | | track\$1counts | Coleta estatísticas sobre a atividade do banco de dados. | – | | track\$1functions | Coleta estatísticas em nível de função sobre a atividade do banco de dados. | pl | | track\$1io\$1timing | Coleta estatísticas de tempo sobre atividades de E/S do banco de dados. | 1 | | track\$1wal\$1io\$1timing | Coleta estatísticas de tempo da atividade de WAL. | – | | transform\$1null\$1equals | Trata expr=NULL como expr IS NULL. | – | | update\$1process\$1title | Atualiza o título do processo para mostrar o comando SQL ativo. | – | | vacuum\$1cost\$1delay | (ms) Atraso de custo de vacuum em milissegundos. | – | | vacuum\$1cost\$1limit | Valor do custo de vacuum disponível antes da suspensão. | – | | vacuum\$1cost\$1page\$1dirty | Custo de vacuum para uma página suja por vacuum. | – | | vacuum\$1cost\$1page\$1hit | Custo de vacuum para uma página encontrada no cache do buffer. | – | | vacuum\$1cost\$1page\$1miss | Custo de vacuum para uma página não encontrada no cache do buffer. | 0 | | vacuum\$1defer\$1cleanup\$1age | Número de transações pelas quais a limpeza VACUUM e HOT deve ser adiada, se houver. | – | | vacuum\$1failsafe\$1age | Idade na qual o VACUUM deve ser acionado à prova de falha para evitar uma interrupção de wraparound. | 1200000000 | | vacuum\$1freeze\$1min\$1age | Idade mínima na qual o VACUUM deve congelar uma linha de tabela. | – | | vacuum\$1freeze\$1table\$1age | Idade na qual o VACUUM deve varrer uma tabela inteira para congelar tuplas. | – | | vacuum\$1multixact\$1failsafe\$1age | Idade Multixact na qual o VACUUM deve ser acionado à prova de falha para evitar uma interrupção de wraparound. | 1200000000 | | vacuum\$1multixact\$1freeze\$1min\$1age | Idade mínima na qual o VACUUM deve congelar uma linha de tabela MultiXactId. | – | | vacuum\$1multixact\$1freeze\$1table\$1age | Idade multiexact na qual o VACUUM deve varrer uma tabela inteira para congelar tuplas. | – | | wal\$1buffers | (8 kB) Define o número de buffers da página de disco na memória compartilhada para WAL. | – | | wal\$1receiver\$1create\$1temp\$1slot | Define se um receptor WAL deve criar um slot de replicação temporário se nenhum slot permanente estiver configurado. | 0 | | wal\$1receiver\$1status\$1interval | (s) Define o intervalo máximo entre os relatórios de status do receptor WAL para o primário. | – | | wal\$1receiver\$1timeout | (ms) Define o tempo máximo de espera para receber dados do primário. | 30000 | | wal\$1sender\$1timeout | (ms) Define o tempo máximo para aguardar a replicação do WAL. | – | | work\$1mem | (kB) Define o máximo de memória a ser usada para espaços de trabalho de consulta. | – | | xmlbinary | Define como valores binários devem ser codificados em XML. | – | | xmloption | Define se dados XML em operações de análise e serialização implícitas são considerados documentos ou fragmentos de conteúdo. | – | ## Parâmetros no nível da instância do Aurora PostgreSQL É possível visualizar parâmetros no nível da instância disponíveis para uma versão do Aurora PostgreSQL usando o Console de Gerenciamento da AWS, a AWS CLI ou a API do Amazon RDS. Para obter informações sobre como visualizar os parâmetros em grupos de parâmetros de banco de dados do Aurora PostgreSQL no console do RDS, consulte [Visualizar valores de parâmetros para um grupo de parâmetros de banco de dados no Amazon Aurora](USER_WorkingWithParamGroups.Viewing.md). Alguns parâmetros no nível de instância não estão disponíveis em todas as versões e alguns estão sendo descontinuados. Para obter informações sobre como visualizar os parâmetros de uma versão específica do Aurora PostgreSQL, consulte [Exibindo parâmetros de banco de dados e de cluster de bancos de dados Aurora PostgreSQL](#AuroraPostgreSQL.Reference.ParameterGroups-viewing-parameters). Por exemplo, a tabela a seguir lista os parâmetros que se aplicam a uma instância de banco de dados específica em um cluster de bancos de dados do Aurora PostgreSQL. Esta lista foi gerada executando o comando da AWS CLI [describe-db-parameters](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-parameters.html) com `default.aurora-postgresql14` para o valor `--db-parameter-group-name`. Para obter uma lista dos parâmetros de cluster de banco de dados para o mesmo grupo de parâmetros padrão do banco de dados, consulte [Parâmetros no nível do cluster do Aurora PostgreSQL](#AuroraPostgreSQL.Reference.Parameters.Cluster). | Nome do parâmetro | Descrição | Padrão | | --- | --- | --- | | apg\$1enable\$1batch\$1mode\$1function\$1execution | Permite que as funções em modo em lote processem conjuntos de linhas de cada vez. | – | | apg\$1enable\$1correlated\$1any\$1transform | Permite que o planejador transforme ANY Sublink correlacionado (subconsulta IN/NOT IN) para JOIN quando possível. | – | | apg\$1enable\$1function\$1migration | Permite que o planejador migre funções escalares elegíveis para a cláusula FROM. | – | | apg\$1enable\$1not\$1in\$1transform | Permite que o planejador transforme a subconsulta NOT IN em ANTI JOIN quando possível. | – | | apg\$1enable\$1remove\$1redundant\$1inner\$1joins | Permite que o planejador remova junções internas redundantes. | – | | apg\$1enable\$1semijoin\$1push\$1down | Permite o uso de filtros de semijunção para junções de hash. | – | | apg\$1plan\$1mgmt.capture\$1plan\$1baselines | Modo de linha de base do plano de captura. manual: habilita a captura de plano para qualquer instrução SQL, desativado: desabilita captura de plano, automático: habilita a captura de plano para instruções em pg\$1stat\$1statement que atendam aos critérios de elegibilidade. | desligar | | apg\$1plan\$1mgmt.max\$1databases | Define o número máximo de bancos de dados que podem gerenciar consultas usando apg\$1plan\$1mgmt. | 10 | | apg\$1plan\$1mgmt.max\$1plans | Define o número máximo de planos que podem ser armazenados em cache por apg\$1plan\$1mgmt. | 10000 | | apg\$1plan\$1mgmt.plan\$1retention\$1period | Número máximo de dias desde que um plano foi last\$1used antes de um plano ser excluído automaticamente. | 32 | | apg\$1plan\$1mgmt.unapproved\$1plan\$1execution\$1threshold | Custo total estimado do plano abaixo do qual um plano não aprovado será executado. | 0 | | apg\$1plan\$1mgmt.use\$1plan\$1baselines | Usa somente planos aprovados ou fixos para instruções gerenciadas. | false | | application\$1name | Define o nome da aplicação a ser informada em estatísticas e logs. | – | | aurora\$1compute\$1plan\$1id | Monitora planos de execução de consultas para detectar planos de execução que contribuem com a carga de banco de dados atual e para monitorar as estatísticas de desempenho de planos de execução ao longo do tempo. Consulte mais informações em [Monitoring query execution plans for Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraPostgreSQL.Monitoring.Query.Plans.html). | ativado | | aurora\$1temp\$1space\$1size | (MB) Define o tamanho do espaço alocado para objetos temporários habilitados para leituras otimizadas em clusters do Aurora otimizados para E/S com classes de instância compatíveis. | DBInstanceClassMemory/524288 | | authentication\$1timeout | (s) Define o tempo máximo permitido para concluir a autenticação de cliente. | – | | auto\$1explain.log\$1analyze | Usa EXPLAIN ANALYZE para registro em log de planos. | – | | auto\$1explain.log\$1buffers | Uso de buffers de log. | – | | auto\$1explain.log\$1format | Formato EXPLAIN a ser usado para registro em log de planos. | – | | auto\$1explain.log\$1min\$1duration | Define o tempo de execução mínimo acima do qual as instruções serão registradas em log. | – | | auto\$1explain.log\$1nested\$1statements | Registrar instruções aninhadas. | – | | auto\$1explain.log\$1timing | Coleta dados de tempo, não apenas contagens de linhas. | – | | auto\$1explain.log\$1triggers | Inclui estatísticas do acionador nos planos. | – | | auto\$1explain.log\$1verbose | Usa EXPLAIN VERBOSE para registro em log de planos. | – | | auto\$1explain.sample\$1rate | Fração de consultas a serem processadas. | – | | babelfishpg\$1tds.listen\$1addresses | Define o nome do host ou um ou mais endereços IP para ouvir o TDS. | \$1 | | babelfishpg\$1tds.tds\$1debug\$1log\$1level | Define o nível de registro em log no TDS, 0 desabilita o registro em log | 1 | | backend\$1flush\$1after | (8 Kb) Número de páginas após as quais as gravações executadas anteriormente são liberadas para o disco. | – | | bytea\$1output | Define o formato da saída para bytes. | – | | check\$1function\$1bodies | Verifica corpos de funções durante CREATE FUNCTION. | – | | client\$1connection\$1check\$1interval | Define o intervalo de tempo entre as verificações de desconexão durante a execução de consultas. | – | | client\$1min\$1messages | Define os níveis de mensagem enviados ao cliente. | – | | config\$1file | Define o arquivo de configuração principal dos servidores. | /rdsdbdata/config/postgresql.conf | | constraint\$1exclusion | Permite que o planejador use restrições para otimizar consultas. | – | | cpu\$1index\$1tuple\$1cost | Define a estimativa do planejador sobre o custo do processamento de cada entrada de índice durante uma verificação de índice. | – | | cpu\$1operator\$1cost | Define a estimativa do planejador sobre o custo do processamento de cada operador ou chamada de função. | – | | cpu\$1tuple\$1cost | Define a estimativa do planejador sobre o custo do processamento de cada tupla (linha). | – | | cron.database\$1name | Define o banco de dados para armazenar tabelas de metadados pg\$1cron | postgres | | cron.log\$1run | Registra todos os trabalhos executados na tabela job\$1run\$1details | ativado | | cron.log\$1statement | Registre todas as instruções cron antes da execução. | desligar | | cron.max\$1running\$1jobs | O número máximo de trabalhos que podem ser executados simultaneamente. | 5 | | cron.use\$1background\$1workers | Habilita operadores em segundo plano para pg\$1cron | ativado | | cursor\$1tuple\$1fraction | Define a estimativa do planejador sobre a fração de linhas de um cursor que serão recuperadas. | – | | db\$1user\$1namespace | Ativa nomes de usuário por banco de dados. | – | | deadlock\$1timeout | (ms) Define o tempo de espera em um bloqueio antes de verificar a existência de um deadlock. | – | | debug\$1pretty\$1print | Recua exibições de árvores de análise e plano. | – | | debug\$1print\$1parse | Registra a árvore de análise de cada consulta. | – | | debug\$1print\$1plan | Registra o plano de execução de cada consulta. | – | | debug\$1print\$1rewritten | Registra a árvore de análise regravada de cada consulta. | – | | default\$1statistics\$1target | Define o destino de estatísticas padrão. | – | | default\$1transaction\$1deferrable | Define o status padrão postergável de novas transações. | – | | default\$1transaction\$1isolation | Define o nível de isolamento de transação de cada nova transação. | – | | default\$1transaction\$1read\$1only | Define o status padrão somente leitura de novas transações. | – | | effective\$1cache\$1size | (8 kB) Define a pressuposição do planejador sobre o tamanho do cache de disco. | SUM(DBInstanceClassMemory/12038,-50003 | | effective\$1io\$1concurrency | Número de solicitações simultâneas que podem ser manipuladas de forma eficiente pelo subsistema de disco. | – | | enable\$1async\$1append | Habilita o uso do planejador de planos de anexação assíncronos. | – | | enable\$1bitmapscan | Habilita o uso do planejador de planos de verificação de bitmap. | – | | enable\$1gathermerge | Habilita o uso do planejador de planos de junção de mesclagem. | – | | enable\$1hashagg | Habilita o uso do planejador de planos de agregação em hash. | – | | enable\$1hashjoin | Habilita o uso do planejador de planos de junção hash. | – | | enable\$1incremental\$1sort | Habilita o uso do planejador de etapas de classificação incremental. | – | | enable\$1indexonlyscan | Habilita o uso do planejador de planos de verificação somente de índice. | – | | enable\$1indexscan | Habilita o uso do planejador de planos de verificação de índice. | – | | enable\$1material | Habilita o uso do planejador da materialização. | – | | enable\$1memoize | Habilita o uso do planejador da memoização | – | | enable\$1mergejoin | Habilita o uso do planejador de planos de junção de mesclagem. | – | | enable\$1nestloop | Habilita o uso do planejador de planos de junção de loop aninhado. | – | | enable\$1parallel\$1append | Habilita o uso do planejador de planos de anexação paralelos. | – | | enable\$1parallel\$1hash | Habilita o uso do planejador de planos de hash paralelos. | – | | enable\$1partition\$1pruning | Habilita a remoção de partição em tempo de planejamento e tempo de execução. | – | | enable\$1partitionwise\$1aggregate | Habilita agregação e agrupamento por partição. | – | | enable\$1partitionwise\$1join | Habilita a junção por partição. | – | | enable\$1seqscan | Habilita o uso do planejador de planos de verificação sequencial. | – | | enable\$1sort | Habilita o uso do planejador de etapas de classificação explícitas. | – | | enable\$1tidscan | Habilita o uso do planejador de planos de verificação TID. | – | | escape\$1string\$1warning | Avisa sobre escapes de barra invertida (\$1) em literais de string comuns. | – | | exit\$1on\$1error | Encerra a sessão em qualquer erro. | – | | force\$1parallel\$1mode | Força o uso de instalações de consulta paralela. | – | | from\$1collapse\$1limit | Define o tamanho da lista FROM além do qual subconsultas não são recolhidas. | – | | geqo | Permite a otimização de consultas genéticas. | – | | geqo\$1effort | GEQO: esforço é usado para definir o padrão para outros parâmetros GEQO. | – | | geqo\$1generations | GEQO: número de iterações do algoritmo. | – | | geqo\$1pool\$1size | GEQO: número de indivíduos na população. | – | | geqo\$1seed | GEQO: propagação para seleção de caminho aleatório. | – | | geqo\$1selection\$1bias | GEQO: pressão seletiva dentro da população. | – | | geqo\$1threshold | Define o limite de itens FROM além do qual o GEQO é usado. | – | | gin\$1fuzzy\$1search\$1limit | Define o resultado máximo permitido para pesquisa exata por GIN. | – | | gin\$1pending\$1list\$1limit | (kB) Define o tamanho máximo da lista pendente para o índice GIN. | – | | hash\$1mem\$1multiplier | Múltiplos de work\$1mem para usar em tabelas de hash. | – | | hba\$1file | Define o arquivo de configuração do hba dos servidores. | /rdsdbdata/config/pg\$1hba.conf | | hot\$1standby\$1feedback | Permite feedback de um standby a quente para o primário que evitará conflitos de consulta. | ativado | | ident\$1file | Define o arquivo de configuração de ident dos servidores. | /rdsdbdata/config/pg\$1ident.conf | | idle\$1in\$1transaction\$1session\$1timeout | (ms) Define a duração máxima permitida de qualquer transação inativa. | 86400000 | | idle\$1session\$1timeout | Encerra qualquer sessão que tenha ficado ociosa (ou seja, aguardando uma consulta do cliente), mas não em uma transação aberta por um tempo maior que o especificado. | – | | join\$1collapse\$1limit | Define o tamanho da lista FROM além do qual constructos JOIN não são nivelados. | – | | lc\$1messages | Define o idioma em que as mensagens são exibidas. | – | | listen\$1addresses | Define o nome do host ou os endereços IP para escutar. | \$1 | | lo\$1compat\$1privileges | Habilita o modo de compatibilidade com versões anteriores para verificações de privilégios em objetos grandes. | 0 | | log\$1connections | Registra cada conexão bem-sucedida. | – | | log\$1destination | Define o destino para a saída de log do servidor. | stderr | | log\$1directory | Define o diretório de destino para arquivos de log. | /rdsdbdata/log/error | | log\$1disconnections | Registra o fim de uma sessão, incluindo a duração. | – | | log\$1duration | Registra a duração de cada instrução SQL concluída. | – | | log\$1error\$1verbosity | Define a verbosidade das mensagens registradas. | – | | log\$1executor\$1stats | Grava estatísticas de desempenho do executor no log do servidor. | – | | log\$1file\$1mode | Define as permissões de arquivo para arquivos de log. | 0644 | | log\$1filename | Define o padrão de nome de arquivo para arquivos de log. | postgresql.log.%Y-%m-%d-%H%M | | logging\$1collector | Inicia um subprocesso para capturar a saída stderr e/ou csvlogs em arquivos de log. | 1 | | log\$1hostname | Registra o nome do host nos logs de conexão. | 0 | | logical\$1decoding\$1work\$1mem | (kB) Essa quantidade de memória pode ser usada por cada buffer de reordenamento interno antes de espalhar para o disco. | – | | log\$1line\$1prefix | Controla informações prefixadas para cada linha de log. | %t:%r:%u@%d:%p]: | | log\$1lock\$1waits | Registra esperas de bloqueio longas. | – | | log\$1min\$1duration\$1sample | (ms) Define o tempo de execução mínimo acima do qual as declarações serão registradas em log. A amostragem é determinada por log\$1statement\$1sample\$1rate. | – | | log\$1min\$1duration\$1statement | (ms) Define o tempo de execução mínimo acima do qual as declarações serão registradas em log. | – | | log\$1min\$1error\$1statement | Faz com que todas as instruções que geram um erro igual ou acima desse nível sejam registradas em log. | – | | log\$1min\$1messages | Define os níveis de mensagem registrados. | – | | log\$1parameter\$1max\$1length | (B) Quando as declarações de registro em log limitam os valores de parâmetros registrados em log aos primeiros N bytes. | – | | log\$1parameter\$1max\$1length\$1on\$1error | (B) Quando o relato de um erro limita os valores de parâmetros registrados em log aos primeiros N bytes. | – | | log\$1parser\$1stats | Grava estatísticas de desempenho do analisador no log do servidor. | – | | log\$1planner\$1stats | Grava estatísticas de desempenho do planejador no log do servidor. | – | | log\$1replication\$1commands | Registra cada comando de replicação. | – | | log\$1rotation\$1age | (min) A alternância automática de arquivos de log ocorrerá depois de N minutos. | 60 | | log\$1rotation\$1size | (kB) A alternância automática de arquivos de log ocorrerá depois de N kilobytes. | 100000 | | log\$1statement | Define o tipo de instruções registradas. | – | | log\$1statement\$1sample\$1rate | Fração de instruções que excedem log\$1min\$1duration\$1sample a serem registradas em log. | – | | log\$1statement\$1stats | Grava estatísticas de desempenho cumulativas no log do servidor. | – | | log\$1temp\$1files | (kB) Registra o uso de arquivos temporários maiores do que esse número de kilobytes. | – | | log\$1timezone | Define o fuso horário a ser usado em mensagens de log. | UTC | | log\$1truncate\$1on\$1rotation | Trunca os arquivos de log existentes com o mesmo nome durante a alternância do log. | 0 | | maintenance\$1io\$1concurrency | Uma variante de effective\$1io\$1concurrency usada para trabalhos de manutenção. | 1 | | maintenance\$1work\$1mem | (kB) Define a memória máxima a ser usada para operações de manutenção. | GREATEST(DBInstanceClassMemory/63963136\$11024,65536 | | max\$1connections | Define o número máximo de conexões simultâneas. | LEAST(DBInstanceClassMemory/9531392,5000 | | max\$1files\$1per\$1process | Define o número máximo de arquivos abertos simultaneamente para cada processo do servidor. | – | | max\$1locks\$1per\$1transaction | Define o número máximo de bloqueios por transação. | 64 | | max\$1parallel\$1maintenance\$1workers | Define o número máximo de processos em paralelo por operação de manutenção. | – | | max\$1parallel\$1workers | Define o número máximo de operadores em paralelo que podem estar ativos de uma só vez. | GREATEST(\$1DBInstanceVCPU/2,8 | | max\$1parallel\$1workers\$1per\$1gather | Define o número máximo de processos em paralelo por nó do executor. | – | | max\$1pred\$1locks\$1per\$1page | Define o número máximo de tuplas bloqueadas por predicado por página. | – | | max\$1pred\$1locks\$1per\$1relation | Define o número máximo de páginas e tuplas bloqueadas por predicado por relação. | – | | max\$1pred\$1locks\$1per\$1transaction | Define o número máximo de bloqueios de predicado por transação. | – | | max\$1slot\$1wal\$1keep\$1size | (MB) Os slots de replicação serão marcados como falhos e segmentos liberados para exclusão ou reciclagem se esse espaço for ocupado pelo WAL no disco. | – | | max\$1stack\$1depth | (kB) Define a profundidade máxima da pilha, em kilobytes. | 6144 | | max\$1standby\$1streaming\$1delay | (ms) Define o atraso máximo antes de cancelar consultas quando um servidor em standby a quente está processando dados do WAL em transmissão. | 14000 | | max\$1worker\$1processes | Define o número máximo de processos de operadores simultâneos. | GREATEST(\$1DBInstanceVCPU\$12,8 | | min\$1dynamic\$1shared\$1memory | (MB) Quantidade de memória compartilhada dinâmica reservada na inicialização. | – | | min\$1parallel\$1index\$1scan\$1size | (8kB) Define a quantidade mínima de dados de índice para uma varredura paralela. | – | | min\$1parallel\$1table\$1scan\$1size | (8kB) Define a quantidade mínima de dados de tabela para uma varredura paralela. | – | | old\$1snapshot\$1threshold | (min) O tempo antes de um snapshot ser muito antigo para ler as páginas alteradas depois que o snapshot foi tirado. | – | | parallel\$1leader\$1participation | Controla se Reunir e Reunir mesclagem também executam subplanos. | – | | parallel\$1setup\$1cost | Define a estimativa dos planejadores do custo de inicialização de processos de operadores para consulta paralela. | – | | parallel\$1tuple\$1cost | Define a estimativa dos planejadores do custo de passar cada tupla (linha) do operador para o backend primário. | – | | pgaudit.log | Especifica quais classes de instruções serão registradas pelo registro em log de auditoria de sessão. | – | | pgaudit.log\$1catalog | Especifica que o registro em log da sessão deve ser habilitado no caso em que todas as relações em uma instrução estão em pg\$1catalog. | – | | pgaudit.log\$1level | Especifica o nível de log que será usado para entradas de log. | – | | pgaudit.log\$1parameter | Especifica que o registro em log de auditoria deve incluir os parâmetros que foram passados com a instrução. | – | | pgaudit.log\$1relation | Especifica se o registro em log de auditoria de sessão deve criar uma entrada de log separada para cada relação (TABLE, VIEW etc.) referenciada em uma declaração SELECT ou DML. | – | | pgaudit.log\$1statement\$1once | Especifica se o registro incluirá o texto e os parâmetros da instrução com a primeira entrada de log para uma combinação de instrução/subinstrução ou com cada entrada. | – | | pgaudit.role | Especifica a função primária a ser usada para o registro em log de auditoria de objetos. | – | | pg\$1bigm.enable\$1recheck | Ele especifica se deseja executar a Reverificação, que é um processo interno de pesquisa de texto completo. | ativado | | pg\$1bigm.gin\$1key\$1limit | Ele especifica o número máximo de 2 gramas da palavra-chave de pesquisa a ser usada para pesquisa de texto completo. | 0 | | pg\$1bigm.last\$1update | Ele relata a última data atualizada do módulo pg\$1bigm. | 2013.11.22 | | pg\$1bigm.similarity\$1limit | Ele especifica o limite mínimo usado pela pesquisa por similaridade. | 0.3 | | pg\$1hint\$1plan.debug\$1print | Registra os resultados da análise de dicas. | – | | pg\$1hint\$1plan.enable\$1hint | Força o planejador a usar planos especificados no comentário de dica anterior à consulta. | – | | pg\$1hint\$1plan.enable\$1hint\$1table | Força o planejador a não receber dicas usando pesquisas de tabela. | – | | pg\$1hint\$1plan.message\$1level | Nível da mensagem de mensagens de depuração. | – | | pg\$1hint\$1plan.parse\$1messages | Nível de mensagem de erros de análise. | – | | pglogical.batch\$1inserts | Inserções em lote, se possível | – | | pglogical.conflict\$1log\$1level | Define o nível de log usado para registrar em log conflitos resolvidos. | – | | pglogical.conflict\$1resolution | Define o método usado para resolução de conflitos para conflitos resolvíveis. | – | | pglogical.extra\$1connection\$1options | opções de conexão para adicionar a todas as conexões de nó de pares | – | | pglogical.synchronous\$1commit | Valor de confirmação síncrona específica do pglogical | – | | pglogical.use\$1spi | Usa SPI em vez de API de baixo nível para aplicar alterações | – | | pg\$1similarity.block\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.block\$1threshold | Define o limite usado pela função de similaridade de bloco. | – | | pg\$1similarity.block\$1tokenizer | Define o tokenizador para a função de similaridade de bloco. | – | | pg\$1similarity.cosine\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.cosine\$1threshold | Define o limite usado pela função de similaridade de cosseno. | – | | pg\$1similarity.cosine\$1tokenizer | Define o tokeniziador para a função de similaridade de cosseno. | – | | pg\$1similarity.dice\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.dice\$1threshold | Define o limite usado pela medida de similaridade de dados. | – | | pg\$1similarity.dice\$1tokenizer | Define o tokenizador para a medida de similaridade de dados. | – | | pg\$1similarity.euclidean\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.euclidean\$1threshold | Define o limite usado pela medida de similaridade euclidiana. | – | | pg\$1similarity.euclidean\$1tokenizer | Define o tokenizador para a medida de similaridade euclidiana. | – | | pg\$1similarity.hamming\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.hamming\$1threshold | Define o limite usado pela métrica de similaridade de bloco. | – | | pg\$1similarity.jaccard\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.jaccard\$1threshold | Define o limite usado pela medida de similaridade Jaccard. | – | | pg\$1similarity.jaccard\$1tokenizer | Define o tokenizador para a medida de similaridade Jaccard. | – | | pg\$1similarity.jaro\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.jaro\$1threshold | Define o limite usado pela medida de similaridade Jaro. | – | | pg\$1similarity.jarowinkler\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.jarowinkler\$1threshold | Define o limite usado pela medida de similaridade Jarowinkler. | – | | pg\$1similarity.levenshtein\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.levenshtein\$1threshold | Define o limite usado pela medida de similaridade Levenshtein. | – | | pg\$1similarity.matching\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.matching\$1threshold | Define o limite usado pela medida de similaridade de Coeficiente de correspondência. | – | | pg\$1similarity.matching\$1tokenizer | Define o tokenizador para a medida de similaridade de Coeficiente de correspondência. | – | | pg\$1similarity.mongeelkan\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.mongeelkan\$1threshold | Define o limite usado pela medida de similaridade Monge-Elkan. | – | | pg\$1similarity.mongeelkan\$1tokenizer | Define o tokenizador para a medida de similaridade Monge-Elkan. | – | | pg\$1similarity.nw\$1gap\$1penalty | Define a penalidade de lacuna usada pela medida de similaridade Needleman-Wunsch. | – | | pg\$1similarity.nw\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.nw\$1threshold | Define o limite usado pela medida de similaridade Needleman-Wunsch. | – | | pg\$1similarity.overlap\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.overlap\$1threshold | Define o limite usado pela medida de similaridade do Coeficiente de sobreposição. | – | | pg\$1similarity.overlap\$1tokenizer | Define o tokenizador para a medida de similaridade de coeficientes de sobreposição. | – | | pg\$1similarity.qgram\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.qgram\$1threshold | Define o limite usado pela medida de similaridade Q-Gram. | – | | pg\$1similarity.qgram\$1tokenizer | Define o tokenizador para a medida Q-Gram. | – | | pg\$1similarity.swg\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.swg\$1threshold | Define o limite usado pela medida de similaridade Smith-Waterman-Gotoh. | – | | pg\$1similarity.sw\$1is\$1normalized | Define se o valor do resultado é normalizado ou não. | – | | pg\$1similarity.sw\$1threshold | Define o limite usado pela medida de similaridade Smith-Waterman. | – | | pg\$1stat\$1statements.max | Define o número máximo de instruções rastreadas por pg\$1stat\$1statements. | – | | pg\$1stat\$1statements.save | Salva as estatísticas pg\$1stat\$1statements em todas os desligamentos do servidor. | – | | pg\$1stat\$1statements.track | Seleciona quais instruções são rastreadas por pg\$1stat\$1statements. | – | | pg\$1stat\$1statements.track\$1planning | Seleciona se a duração do planejamento é rastreada por pg\$1stat\$1statements. | – | | pg\$1stat\$1statements.track\$1utility | Seleciona se os comandos do utilitário são rastreados por pg\$1stat\$1statements. | – | | postgis.gdal\$1enabled\$1drivers | Habilita ou desabilita drivers GDAL usados com PostGIS no Postgres 9.3.5 e posteriores. | ENABLE\$1ALL | | quote\$1all\$1identifiers | Ao gerar fragmentos SQL, cita todos os identificadores. | – | | random\$1page\$1cost | Define a estimativa do planejador sobre o custo de uma página de disco não sequencialmente buscada. | – | | rds.enable\$1memory\$1management | Melhora os recursos de gerenciamento de memória no Aurora PostgreSQL 12.17, 13.13, 14.10, 15.5 e versões posteriores, evitando problemas de estabilidade e reinicializações do banco de dados decorrentes de memória livre insuficiente. Para obter mais informações, consulte [Gerenciamento aprimorado de memória no Aurora PostgreSQLLimitação](AuroraPostgreSQL.BestPractices.memory.management.md). | Verdadeiro | | rds.force\$1admin\$1logging\$1level | Consulta mensagens de log para ações de usuário administrador do RDS em bancos de dados de clientes. | – | | rds.log\$1retention\$1period | O Amazon RDS excluirá o log do PostgreSQL com mais de N minutos. | 4320 | | rds.memory\$1allocation\$1guard | Melhora os recursos de gerenciamento de memória no Aurora PostgreSQL 11.21, 12.16, 13.12, 14.9, 15.4 e versões anteriores, evitando problemas de estabilidade e reinicializações do banco de dados decorrentes de memória livre insuficiente. Para obter mais informações, consulte [Gerenciamento aprimorado de memória no Aurora PostgreSQLLimitação](AuroraPostgreSQL.BestPractices.memory.management.md). | Falso | | rds.pg\$1stat\$1ramdisk\$1size | Tamanho das estatísticas ramdisk em MB. Um valor diferente de zero configurará o ramdisk. | 0 | | rds.rds\$1superuser\$1reserved\$1connections | Define o número de slots de conexão reservados para rds\$1superusers. Esse parâmetro só está disponível nas versões 15 e posterior. Para ter mais informações, consulte [reserved connections](https://www.postgresql.org/docs/current/runtime-config-connection.html#GUC-RESERVED-CONNECTIONS) na documentação do PostgreSQL. | 2 | | rds.superuser\$1variables | Lista de variáveis somente superusuário para as quais elevamos as instruções de modificação rds\$1superuser. | session\$1replication\$1role | | remove\$1temp\$1files\$1after\$1crash | Remove arquivos temporários após falha de backend. | 0 | | restart\$1after\$1crash | Reinicializa o servidor após falha de backend. | – | | row\$1security | Habilita a segurança de linha. | – | | search\$1path | Define a ordem de pesquisa do esquema de nomes que não são qualificados para esquema. | – | | seq\$1page\$1cost | Define a estimativa do planejador sobre o custo de uma página de disco sequencialmente buscada. | – | | session\$1replication\$1role | Define o comportamento de sessões para disparadores e regras de regravação. | – | | shared\$1buffers | (8kB) Define o número de buffers de memória compartilhada usados pelo servidor. | SUM(DBInstanceClassMemory/12038,-50003) | | shared\$1preload\$1libraries | Lista bibliotecas compartilhadas para pré-carregar no servidor. | pg\$1stat\$1statements | | ssl\$1ca\$1file | Localização do arquivo de autoridade do servidor SSL. | /rdsdbdata/rds-metadata/ca-cert.pem | | ssl\$1cert\$1file | Localização do arquivo de certificado do servidor SSL. | /rdsdbdata/rds-metadata/server-cert.pem | | ssl\$1crl\$1dir | Localização do diretório da lista de revogação de certificados SSL. | /rdsdbdata/rds-metadata/ssl\$1crl\$1dir/ | | ssl\$1key\$1file | Localização do arquivo de chave privada do servidor SSL | /rdsdbdata/rds-metadata/server-key.pem | | standard\$1conforming\$1strings | Faz com que strings ... tratem barras invertidas literalmente. | – | | statement\$1timeout | (ms) Define a duração máxima permitida de qualquer declaração. | – | | stats\$1temp\$1directory | Grava arquivos de estatísticas temporárias no diretório especificado. | /rdsdbdata/db/pg\$1stat\$1tmp | | superuser\$1reserved\$1connections | Define o número de slots de conexão reservados para superusuários. | 3 | | synchronize\$1seqscans | Habilita varreduras sequenciais sincronizadas. | – | | tcp\$1keepalives\$1count | Número máximo de retransmissões de keepalives TCP. | – | | tcp\$1keepalives\$1idle | (s) Tempo entre a emissão de keepalives TCP. | – | | tcp\$1keepalives\$1interval | (s) Tempo entre retransmissões de keepalives TCP. | – | | temp\$1buffers | (8kB) Define o número máximo de buffers temporários usado por cada sessão. | – | | temp\$1file\$1limit | Restringe a quantidade total de espaço em disco em kilobytes que um determinado processo PostgreSQL pode usar para arquivos temporários, excluindo o espaço usado para tabelas temporárias explícitas | -1 | | temp\$1tablespaces | Define os espaços de tabela a serem usados para tabelas temporárias e arquivos de classificação. | – | | track\$1activities | Coleta informações sobre a execução de comandos. | – | | track\$1activity\$1query\$1size | Define o tamanho reservado para pg\$1stat\$1activity.current\$1query, em bytes. | 4096 | | track\$1counts | Coleta estatísticas sobre a atividade do banco de dados. | – | | track\$1functions | Coleta estatísticas em nível de função sobre a atividade do banco de dados. | pl | | track\$1io\$1timing | Coleta estatísticas de tempo sobre atividades de E/S do banco de dados. | 1 | | transform\$1–\$1equals | Trata expr=– como expr IS –. | – | | update\$1process\$1title | Atualiza o título do processo para mostrar o comando SQL ativo. | – | | wal\$1receiver\$1status\$1interval | (s) Define o intervalo máximo entre os relatórios de status do receptor WAL para o primário. | – | | work\$1mem | (kB) Define o máximo de memória a ser usada para espaços de trabalho de consulta. | – | | xmlbinary | Define como valores binários devem ser codificados em XML. | – | | xmloption | Define se dados XML em operações de análise e serialização implícitas são considerados documentos ou fragmentos de conteúdo. | – | # Eventos de espera do Amazon Aurora PostgreSQL Os seguintes são alguns eventos de espera comuns do Aurora PostgreSQL. Para saber mais sobre eventos de espera e como ajustar um cluster de banco de dados do Aurora PostgreSQL, consulte [Ajustar com eventos de espera do Aurora PostgreSQL](AuroraPostgreSQL.Tuning.md). **Activity:ArchiverMain** O processo do arquivador está aguardando atividades. **Activity:AutoVacuumMain** O processo do launcher de autovacuum está aguardando atividades. **Activity:BgWriterHibernate** O processo do gravador em segundo plano está hibernando enquanto aguarda atividades. **Activity:BgWriterMain** O processo do gravador em segundo plano está aguardando atividades. **Activity:CheckpointerMain** O processo do ponteiro de verificação está aguardando atividades. **Activity:LogicalApplyMain** O processo da aplicação de replicação lógica está aguardando atividades. **Activity:LogicalLauncherMain** O processo do launcher de replicação lógica está aguardando atividades. **Activity:PgStatMain** O processo do coletor de estatísticas está aguardando atividades. **Activity:RecoveryWalAll** Um processo está aguardando o log de gravação antecipada (WAL) de um fluxo na recuperação. **Activity:RecoveryWalStream** O processo de inicialização está aguardando a chegada do log de gravação antecipada (WAL) durante a recuperação da transmissão. **Activity:SysLoggerMain** O processo do syslogger está aguardando atividades. **Activity:WalReceiverMain** O processo do receptor do log de gravação antecipada (WAL) está aguardando atividades. **Activity:WalSenderMain** O processo do emissor do log de gravação antecipada (WAL) está aguardando atividades. **Activity:WalWriterMain** O processo do gravador do log de gravação antecipada (WAL) está aguardando atividades. **BufferPin:BufferPin** Um processo está aguardando para adquirir um pino exclusivo em um buffer. **Client:GSSOpenServer** Um processo está aguardando para ler dados do cliente enquanto estabelece uma sessão Generic Security Service Application Program Interface (GSSAPI). **Client:ClientRead** Um processo de backend está aguardando para receber dados de um cliente PostgreSQL. Para obter mais informações, consulte [Client:ClientRead](apg-waits.clientread.md). **Client:ClientWrite** Um processo de backend está aguardando para enviar mais dados a um cliente PostgreSQL. Para obter mais informações, consulte [Client:ClientWrite](apg-waits.clientwrite.md). **Client:LibPQWalReceiverConnect** Um processo está aguardando no receptor do log de gravação antecipada (WAL) para estabelecer a conexão com o servidor remoto. **Client:LibPQWalReceiverReceive** Um processo está aguardando no receptor do log de gravação antecipada (WAL) para receber dados do servidor remoto. **Client:SSLOpenServer** Um processo está aguardando o Secure Sockets Layer (SSL) ao tentar a conexão. **Client:WalReceiverWaitStart** Um processo está aguardando o processo de inicialização enviar dados iniciais para replicação de transmissão. **Client:WalSenderWaitForWAL** Um processo está aguardando o log de gravação antecipada (WAL) ser liberado no processo do emissor do WAL. **Client:WalSenderWriteData** Um processo está aguardando qualquer atividade ao processar respostas do receptor do log de gravação antecipada (WAL) no processo do emissor do WAL. **CPU** Um processo de backend está ativo ou está aguardando a CPU. Para obter mais informações, consulte [CPU](apg-waits.cpu.md). **Extension:extension** Um processo de backend está aguardando uma condição definida por uma extensão ou um módulo. **IO:AuroraEnhancedLogicalWALRead** Um processo de backend está buscando registros de log do volume de captura de dados de alteração (CDC). **IO:AuroraOptimizedReadsCacheRead** Um processo está aguardando uma leitura do cache em camadas do Optimized Reads porque a página não está disponível na memória compartilhada. **IO:AuroraOptimizedReadsCacheSegmentTruncate** Um processo está aguardando o truncamento de um arquivo de segmento de cache em camadas do Optimized Reads. **IO:AuroraOptimizedReadsCacheWrite** O processo de gravação em segundo plano está aguardando o cache em camadas do Optimized Reads **IO:AuroraStorageLogAllocate** Uma sessão está alocando metadados e se preparando para uma gravação do log de transações. **IO:BufFileRead** Quando as operações exigem mais memória do que a quantidade definida por parâmetros de memória de trabalho, o mecanismo cria arquivos temporários no disco. Esse evento de espera ocorre quando as operações leem dos arquivos temporários. Para obter mais informações, consulte [IO:BufFileRead and IO:BufFileWrite](apg-waits.iobuffile.md). **IO:BufFileWrite** Quando as operações exigem mais memória do que a quantidade definida por parâmetros de memória de trabalho, o mecanismo cria arquivos temporários no disco. Esse evento de espera ocorre quando as operações gravam nos arquivos temporários. Para obter mais informações, consulte [IO:BufFileRead and IO:BufFileWrite](apg-waits.iobuffile.md). **IO:ControlFileRead** Um processo está aguardando uma leitura do arquivo `pg_control`. **IO:ControlFileSync** Um processo está aguardando o arquivo `pg_control` alcançar o armazenamento durável. **IO:ControlFileSyncUpdate** Um processo está aguardando uma atualização do arquivo `pg_control` alcançar o armazenamento durável. **IO:ControlFileWrite** Um processo está aguardando uma gravação no arquivo `pg_control`. **IO:ControlFileWriteUpdate** Um processo está aguardando uma gravação atualizar o arquivo `pg_control`. **IO:CopyFileRead** Um processo está aguardando uma leitura durante uma operação de cópia de arquivos. **IO:CopyFileWrite** Um processo está aguardando uma gravação durante uma operação de cópia de arquivos. **IO:DataFileExtend** Um processo está aguardando a extensão de um arquivo de dados de relação. **IO:DataFileFlush** Um processo está aguardando um arquivo de dados de relação alcançar o armazenamento durável. **IO:DataFileImmediateSync** Um processo está aguardando uma sincronização imediata de um arquivo de dados de relação com o armazenamento durável. **IO:DataFilePrefetch** Um processo está aguardando uma pré-busca assíncrona de um arquivo de dados de relação. **IO:DataFileSync** Um processo está aguardando alterações em um arquivo de dados de relação alcançarem o armazenamento durável. **IO:DataFileRead** Um processo de backend tentou encontrar uma página nos buffers compartilhados, não a encontrou e, portanto, fez a sua leitura no armazenamento. Para obter mais informações, consulte [IO:DataFileRead](apg-waits.iodatafileread.md). **IO:DataFileTruncate** Um processo está aguardando o truncamento de um arquivo de dados de relação. **IO:DataFileWrite** Um processo está aguardando uma gravação em um arquivo de dados de relação. **IO:DSMFillZeroWrite** Um processo está aguardando para gravar zero bytes em um arquivo dinâmico de backup de memória compartilhada. **IO:LockFileAddToDataDirRead** Um processo está aguardando uma leitura enquanto adiciona uma linha ao arquivo de bloqueio do diretório de dados. **IO:LockFileAddToDataDirSync** Um processo está aguardando os dados alcançarem o armazenamento durável enquanto adiciona uma linha ao arquivo de bloqueio do diretório de dados. **IO:LockFileAddToDataDirWrite** Um processo está aguardando uma gravação enquanto adiciona uma linha ao arquivo de bloqueio do diretório de dados. **IO:LockFileCreateRead** Um processo está aguardando uma leitura enquanto cria o arquivo de bloqueio do diretório de dados. **IO:LockFileCreateSync** Um processo está aguardando os dados alcançarem o armazenamento durável enquanto cria o arquivo de bloqueio do diretório de dados. **IO:LockFileCreateWrite** Um processo está aguardando uma gravação enquanto cria o arquivo de bloqueio do diretório de dados. **IO:LockFileReCheckDataDirRead** Um processo está aguardando uma leitura durante a reverificação do arquivo de bloqueio do diretório de dados. **IO:LogicalRewriteCheckpointSync** Um processo está aguardando os mapeamentos de regravação lógica alcançarem o armazenamento durável durante um ponto de verificação. **IO:LogicalRewriteMappingSync** Um processo está aguardando os dados de mapeamento alcançarem o armazenamento durável durante uma regravação lógica. **IO:LogicalRewriteMappingWrite** Um processo está aguardando uma gravação de dados de mapeamento durante uma regravação lógica. **IO:LogicalRewriteSync** Um processo está aguardando os mapeamentos de regravação lógica alcançarem o armazenamento durável. **IO:LogicalRewriteTruncate** Um processo está aguardando o truncamento de dados de mapeamento durante uma regravação lógica. **IO:LogicalRewriteWrite** Um processo está aguardando uma gravação de mapeamentos de regravação lógica. **IO:RelationMapRead** Um processo está aguardando uma leitura do arquivo de mapa de relação. **IO:RelationMapSync** Um processo está aguardando o arquivo de mapa de relação alcançar o armazenamento durável. **IO:RelationMapWrite** Um processo está aguardando uma gravação no arquivo de mapa de relação. **IO:ReorderBufferRead** Um processo está aguardando uma leitura durante o gerenciamento do buffer de reordenação. **IO:ReorderBufferWrite** Um processo está aguardando uma gravação durante o gerenciamento do buffer de reordenação. **IO:ReorderLogicalMappingRead** Um processo está aguardando uma leitura de um mapeamento lógico durante o gerenciamento do buffer de reordenação. **IO:ReplicationSlotRead** Um processo está aguardando uma leitura de um arquivo de controle de slot de replicação. **IO:ReplicationSlotRestoreSync** Um processo está aguardando um arquivo de controle de slot de replicação alcançar o armazenamento durável enquanto o restaura na memória. **IO:ReplicationSlotSync** Um processo está aguardando um arquivo de controle de slot de replicação alcançar o armazenamento durável. **IO:ReplicationSlotWrite** Um processo está aguardando uma gravação em um arquivo de controle de slot de replicação. **IO:SLRUFlushSync** Um processo está aguardando os dados simples menos recentemente utilizados (SLRU) alcançarem o armazenamento durável durante um ponto de verificação ou desligamento do banco de dados. **IO:SLRURead** Um processo está aguardando uma leitura de uma página simples menos recentemente utilizada (SLRU). **IO:SLRUSync** Um processo está aguardando os dados simples menos recentemente utilizados (SLRU) alcançarem o armazenamento durável após uma gravação de página. **IO:SLRUWrite** Um processo está aguardando uma gravação de uma página simples menos recentemente utilizada (SLRU). **IO:SnapbuildRead** Um processo está aguardando uma leitura de um snapshot de catálogo histórico serializado. **IO:SnapbuildSync** Um processo está aguardando um snapshot de catálogo histórico serializado alcançar o armazenamento durável. **IO:SnapbuildWrite** Um processo está aguardando uma gravação de um snapshot de catálogo histórico serializado. **IO:TimelineHistoryFileSync** Um processo está aguardando um arquivo de histórico da linha do tempo recebido via replicação de transmissão alcançar o armazenamento durável. **IO:TimelineHistoryFileWrite** Um processo está aguardando uma gravação de um arquivo de histórico da linha do tempo recebido via replicação de transmissão. **IO:TimelineHistoryRead** Um processo está aguardando uma leitura de um arquivo de histórico da linha do tempo. **IO:TimelineHistorySync** Um processo está aguardando um arquivo de histórico da linha do tempo recém-criado alcançar o armazenamento durável. **IO:TimelineHistoryWrite** Um processo está aguardando uma gravação de um arquivo de histórico da linha do tempo recém-criado. **IO:TwophaseFileRead** Um processo está aguardando uma leitura de um arquivo de estado de duas fases. **IO:TwophaseFileSync** Um processo está aguardando um arquivo de estado de duas fases alcançar o armazenamento durável. **IO:TwophaseFileWrite** Um processo está aguardando uma gravação de um arquivo de estado de duas fases. **IO:WALBootstrapSync** Um processo está aguardando o log de gravação antecipada (WAL) alcançar o armazenamento durável durante o bootstrapping. **IO:WALBootstrapWrite** Um processo está aguardando uma gravação de uma página do log de gravação antecipada (WAL) durante o bootstrapping. **IO:WALCopyRead** Um processo está aguardando uma leitura ao criar um novo segmento do log de gravação antecipada (WAL) por meio da cópia de um existente. **IO:WALCopySync** Um processo está aguardando um novo segmento do log de gravação antecipada (WAL), criado por meio da cópia de um existente, alcançar o armazenamento durável. **IO:WALCopyWrite** Um processo está aguardando uma gravação ao criar um novo segmento do log de gravação antecipada (WAL) por meio da cópia de um existente. **IO:WALInitSync** Um processo está aguardando um arquivo do log de gravação antecipada (WAL) recém-inicializado alcançar um armazenamento durável. **IO:WALInitWrite** Um processo está aguardando uma gravação ao inicializar um novo arquivo do log de gravação antecipada (WAL). **IO:WALRead** Um processo está aguardando uma leitura de um arquivo do log de gravação antecipada (WAL). **IO:WALSenderTimelineHistoryRead** Um processo está aguardando uma leitura de um arquivo de histórico da linha do tempo durante um comando de linha do tempo do emissor do WAL. **IO:WALSync** Um processo está aguardando um arquivo do log de gravação antecipada (WAL) alcançar o armazenamento durável. **IO:WALSyncMethodAssign** Um processo está aguardando os dados alcançarem o armazenamento durável enquanto atribui um novo método de sincronização do log de gravação antecipada (WAL). **IO:WALWrite** Um processo está aguardando uma gravação em um arquivo do log de gravação antecipada (WAL). **IO:XactSync** Um processo de backend está aguardando o subsistema de armazenamento do Aurora fazer a confirmação de uma transação regular ou a confirmação ou reversão de uma transação preparada. Para obter mais informações, consulte [IO:XactSync](apg-waits.xactsync.md). **IPC:AuroraLogicalSchemaUpdate** Dois processos de backend estão tentando inserir a mesma entrada no cache do esquema. Um processo continuará enquanto o outro aguarda sua conclusão. **IPC:AuroraOptimizedReadsCacheWriteStop** Um processo está aguardando o gravador em segundo plano interromper a gravação no cache em níveis do Optimized Reads. **IPC:BackupWaitWalArchive** Um processo está aguardando os arquivos do log de gravação antecipada (WAL) necessários para que um backup seja arquivado com êxito. **IPC:BgWorkerShutdown** Um processo está aguardando o encerramento de um operador em segundo plano. **IPC:BgWorkerStartup** Um processo está aguardando o início de um operador em segundo plano. **IPC:BtreePage** Um processo está aguardando o número de página necessário para continuar uma varredura paralela de árvore B para ficar disponível. **IPC:CheckpointDone** Um processo está aguardando a conclusão de um ponto de verificação. **IPC:CheckpointStart** Um processo está aguardando o início de um ponto de verificação. **IPC:ClogGroupUpdate** Um processo está aguardando o líder do grupo atualizar o status da transação no final de uma transação. **IPC:DamRecordTxAck** Um processo de backend gerou um evento de fluxos de atividades de banco de dados e está aguardando esse evento se tornar durável. Para obter mais informações, consulte [IPC:DamRecordTxAck](apg-waits.ipcdamrecordtxac.md). **IPC:ExecuteGather** Um processo está aguardando atividades de um processo filho durante a execução de um nó do plano Gather. **IPC:Hash/Batch/Allocating** Um processo está aguardando um participante de hash paralelo eleito alocar uma tabela de hash. **IPC:Hash/Batch/Electing** Um processo está elegendo um participante de hash paralelo para alocar uma tabela de hash. **IPC:Hash/Batch/Loading** Um processo está aguardando outros participantes de hash paralelos terminarem de carregar uma tabela de hash. **IPC:Hash/Build/Allocating** Um processo está aguardando um participante de hash paralelo eleito alocar a tabela de hash inicial. **IPC:Hash/Build/Electing** Um processo está elegendo um participante de hash paralelo para alocar a tabela de hash inicial. **IPC:Hash/Build/HashingInner** Um processo está aguardando outros participantes de hash paralelos terminarem o hash da relação interna. **IPC:Hash/Build/HashingOuter** Um processo está aguardando outros participantes de hash paralelos terminarem de particionar a relação externa. **IPC:Hash/GrowBatches/Allocating** Um processo está aguardando um participante de hash paralelo eleito alocar mais lotes. **IPC:Hash/GrowBatches/Deciding** Um processo está elegendo um participante de hash paralelo para decidir sobre o crescimento futuro do lote. **IPC:Hash/GrowBatches/Electing** Um processo está elegendo um participante de hash paralelo para alocar mais lotes. **IPC:Hash/GrowBatches/Finishing** Um processo está aguardando um participante de hash paralelo eleito decidir sobre o crescimento futuro do lote. **IPC:Hash/GrowBatches/Repartitioning** Um processo está aguardando outros participantes de hash paralelos terminarem o reparticionamento. **IPC:Hash/GrowBuckets/Allocating** Um processo está aguardando um participante de hash paralelo eleito terminar a alocação de mais buckets. **IPC:Hash/GrowBuckets/Electing** Um processo está elegendo um participante de hash paralelo para alocar mais buckets. **IPC:Hash/GrowBuckets/Reinserting** Um processo está aguardando outros participantes de hash paralelos terminarem de inserir tuplas em novos buckets. **IPC:HashBatchAllocate** Um processo está aguardando um participante de hash paralelo eleito alocar uma tabela de hash. **IPC:HashBatchElect** Um processo está aguardando para eleger um participante de hash paralelo para alocar uma tabela de hash. **IPC:HashBatchLoad** Um processo está aguardando outros participantes de hash paralelos terminarem de carregar uma tabela de hash. **IPC:HashBuildAllocate** Um processo está aguardando um participante de hash paralelo eleito alocar a tabela de hash inicial. **IPC:HashBuildElect** Um processo está aguardando para eleger um participante de hash paralelo para alocar a tabela de hash inicial. **IPC:HashBuildHashInner** Um processo está aguardando outros participantes de hash paralelos terminarem o hash da relação interna. **IPC:'HashBuildHashOuter** Um processo está aguardando outros participantes de hash paralelos terminarem de particionar a relação externa. **IPC:HashGrowBatchesAllocate** Um processo está aguardando um participante de hash paralelo eleito alocar mais lotes. **IPC:'HashGrowBatchesDecide** Um processo está aguardando para eleger um participante de hash paralelo para decidir sobre o crescimento futuro do lote. **IPC:HashGrowBatchesElect** Um processo está aguardando para eleger um participante de hash paralelo para alocar mais lotes. **IPC:HashGrowBatchesFinish** Um processo está aguardando um participante de hash paralelo eleito decidir sobre o crescimento futuro do lote. **IPC:HashGrowBatchesRepartition** Um processo está aguardando outros participantes de hash paralelos terminarem o reparticionamento. **IPC:HashGrowBucketsAllocate** Um processo está aguardando um participante de hash paralelo eleito terminar a alocação de mais buckets. **IPC:HashGrowBucketsElect** Um processo está aguardando para eleger um participante de hash paralelo para alocar mais buckets. **IPC:HashGrowBucketsReinsert** Um processo está aguardando outros participantes de hash paralelos terminarem de inserir tuplas em novos buckets. **IPC:LogicalSyncData** Um processo está aguardando um servidor remoto de replicação lógica enviar dados para sincronização da tabela inicial. **IPC:LogicalSyncStateChange** Um processo está aguardando um servidor remoto de replicação lógica mudar de estado. **IPC:MessageQueueInternal** Um processo está aguardando outro processo ser anexado a uma fila de mensagens compartilhadas. **IPC:MessageQueuePutMessage** Um processo está aguardando para gravar uma mensagem de protocolo em uma fila de mensagens compartilhadas. **IPC:MessageQueueReceive** Um processo está aguardando para receber bytes de uma fila de mensagens compartilhadas. **IPC:MessageQueueSend** Um processo está aguardando para enviar bytes para uma fila de mensagens compartilhadas. **IPC:ParallelBitmapScan** Um processo está aguardando a inicialização de uma varredura de bitmap paralela. **IPC:ParallelCreateIndexScan** Um processo está aguardando operadores paralelos de CREATE INDEX terminarem uma varredura de heap. **IPC:ParallelFinish** Um processo está aguardando operadores paralelos terminarem o cálculo. **IPC:ProcArrayGroupUpdate** Um processo está aguardando o líder do grupo limpar o ID da transação no final de uma transação. **IPC:ProcSignalBarrier** Um processo está aguardando um evento de barreira ser processado por todos os backends. **IPC:Promote** Um processo está aguardando uma promoção para espera. **IPC:RecoveryConflictSnapshot** Um processo está aguardando a resolução de um conflito de recuperação para uma limpeza de vacuum. **IPC:RecoveryConflictTablespace** Um processo está aguardando a resolução de um conflito de recuperação para descartar um espaço de tabela. **IPC:RecoveryPause** Um processo está aguardando a retomada da recuperação. **IPC:ReplicationOriginDrop** Um processo está aguardando uma origem de replicação tornar-se inativa para que ela possa ser descartada. **IPC:ReplicationSlotDrop** Um processo está aguardando um slot de replicação tornar-se inativo para que ele possa ser descartado. **IPC:SafeSnapshot** Um processo está aguardando para obter um snapshot válido para uma transação READ ONLY DEFERRABLE. **IPC:SyncRep** Um processo está aguardando confirmação de um servidor remoto durante a replicação síncrona. **IPC:XactGroupUpdate** Um processo está aguardando o líder do grupo atualizar o status da transação no final de uma transação. **Lock:advisory** Um processo de backend solicitou um bloqueio de consultoria e está aguardando por ele. Para obter mais informações, consulte [Lock:advisory](apg-waits.lockadvisory.md). **Lock:extend** Um processo de backend está aguardando um bloqueio ser liberado para poder estender uma relação. Esse bloqueio é necessário porque apenas um processo de backend pode estender uma relação por vez. Para obter mais informações, consulte [Lock:extend](apg-waits.lockextend.md). **Lock:frozenid** Um processo está aguardando para atualizar `pg_database.datfrozenxid` e `pg_database.datminmxid`. **Lock:object** Um processo está aguardando para obter um bloqueio em um objeto de banco de dados sem relação. **Lock:page** Um processo está aguardando para obter um bloqueio em uma página de uma relação. **Lock:Relation** Um processo de backend aguarda para adquirir um bloqueio em uma relação bloqueada por outra transação. Para obter mais informações, consulte [Lock:Relation](apg-waits.lockrelation.md). **Lock:spectoken** Um processo está aguardando para obter um bloqueio de inserção especulativo. **Lock:speculative token** Um processo está aguardando para adquirir um bloqueio de inserção especulativo. **Lock:transactionid** Uma transação está aguardando um bloqueio em nível de linha. Para obter mais informações, consulte [Lock:transactionid](apg-waits.locktransactionid.md). **Lock:tuple** Um processo de backend está aguardando para adquirir um bloqueio em uma tupla enquanto outro processo de backend mantém um bloqueio conflitante na mesma tupla. Para obter mais informações, consulte [Lock:tuple](apg-waits.locktuple.md). **Lock:userlock** Um processo está aguardando para obter um bloqueio de usuário. **Lock:virtualxid** Um processo está aguardando para obter um bloqueio de ID de transação virtual. **LWLock:AddinShmemInit** Um processo está aguardando para gerenciar a alocação de espaço de uma extensão na memória compartilhada. **LWLock:AddinShmemInitLock** Um processo está aguardando para gerenciar a alocação de espaço na memória compartilhada. **LWLock:async** Um processo está aguardando E/S em um buffer assíncrono (notificação). **LWLock:AsyncCtlLock** Um processo está aguardando para ler ou atualizar um estado de notificação compartilhado. **LWLock:AsyncQueueLock** Um processo está aguardando para ler ou atualizar mensagens de notificação. **LWLock:AuroraOptimizedReadsCacheMapping** Um processo está aguardando para associar um bloco de dados a uma página no cache do Optimized Reads. **LWLock:AutoFile** Um processo está aguardando para atualizar o arquivo `postgresql.auto.conf`. **LWLock:AutoFileLock** Um processo está aguardando para atualizar o arquivo `postgresql.auto.conf`. **LWLock:Autovacuum** Um processo está aguardando para ler ou atualizar o estado atual de operadores de autovacuum. **LWLock:AutovacuumLock** Um operador ou launcher de autovacuum está aguardando para atualizar ou ler o estado atual de operadores de autovacuum. **LWLock:AutovacuumSchedule** Um processo está aguardando para garantir que uma tabela selecionada para autovacuum ainda requer aplicação de vacuum. **LWLock:AutovacuumScheduleLock** Um processo está aguardando para garantir que a tabela que ele selecionou para um vacuum ainda requer aplicação de vacuum. **LWLock:BackendRandomLock** Um processo está aguardando para gerar um número aleatório. **LWLock:BackgroundWorker** Um processo está aguardando para ler ou atualizar o estado do operador em segundo plano. **LWLock:BackgroundWorkerLock** Um processo está aguardando para ler ou atualizar o estado do operador em segundo plano. **LWLock:BtreeVacuum** Um processo está aguardando para ler ou atualizar informações relacionadas a vacuum para um índice de árvores B. **LWLock:BtreeVacuumLock** Um processo está aguardando para ler ou atualizar informações relacionadas a vacuum para um índice de árvores B. **LWLock:buffer\$1content** Um processo de backend está aguardando para adquirir um bloqueio leve no conteúdo de um buffer de memória compartilhada. Para obter mais informações, consulte [LWLock:buffer\$1content (BufferContent)](apg-waits.lockbuffercontent.md). **LWLock:buffer\$1mapping** Um processo de backend está aguardando para associar um bloqueio de dados a um buffer no grupo de buffer compartilhado. Para obter mais informações, consulte [LWLock:buffer\$1mapping](apg-waits.lwl-buffer-mapping.md). **LWLock:BufferIO** Um processo de backend deseja ler uma página na memória compartilhada. O processo está aguardando outros processos terminarem sua E/S para a página. Para obter mais informações, consulte [LWLock:BufferIO (IPC:BufferIO)](apg-waits.lwlockbufferio.md). **LWLock:Checkpoint** Um processo está aguardando para iniciar um ponto de verificação. **LWLock:CheckpointLock** Um processo está aguardando para realizar o ponto de verificação. **LWLock:CheckpointerComm** Um processo está aguardando para gerenciar solicitações `fsync`. **LWLock:CheckpointerCommLock** Um processo está aguardando para gerenciar solicitações `fsync`. **LWLock:clog** Um processo está aguardando E/S em um buffer de entupimento (status da transação). **LWLock:CLogControlLock** Um processo está aguardando para ler ou atualizar o status da transação. **LWLock:CLogTruncationLock** Um processo está aguardando para executar `txid_status` ou atualizar o ID de transação mais antigo disponível para ele. **LWLock:commit\$1timestamp** Um processo está aguardando E/S em um buffer de carimbo de data/hora de confirmação. **LWLock:CommitTs** Um processo está aguardando para ler ou atualizar o último valor definido para um carimbo de data/hora de confirmação de transação. **LWLock:CommitTsBuffer** Um processo está aguardando E/S em um buffer simples menos recentemente utilizado (SLRU) para um carimbo de data/hora de confirmação. **LWLock:CommitTsControlLock** Um processo está aguardando para ler ou atualizar carimbos de data/hora de confirmação de transação. **LWLock:CommitTsLock** Um processo está aguardando para ler ou atualizar o último valor definido para o carimbo de data/hora da transação. **LWLock:CommitTsSLRU** Um processo está aguardando para acessar o cache simples menos recentemente utilizado (SLRU) para um carimbo de data/hora de confirmação. **LWLock:ControlFile** Um processo está aguardando para ler ou atualizar o arquivo `pg_control` ou criar um novo arquivo de log de gravação antecipada (WAL). **LWLock:ControlFileLock** Um processo está aguardando para ler ou atualizar o arquivo de controle ou a criação de um novo arquivo de log de gravação antecipada (WAL). **LWLock:DynamicSharedMemoryControl** Um processo está aguardando para ler ou atualizar informações de alocação de memória compartilhada dinâmica. **LWLock:DynamicSharedMemoryControlLock** Um processo está aguardando para ler ou atualizar o estado de memória compartilhada dinâmica. **LWLock:lock\$1manager** Um processo de backend está aguardando para adicionar ou examinar bloqueios para processos de backend. Ou está aguardando para entrar ou sair de um grupo de bloqueio utilizado pela consulta paralela. Para obter mais informações, consulte [LWLock:lock\$1manager](apg-waits.lw-lock-manager.md). **LWLock:LockFastPath** Um processo está aguardando para ler ou atualizar as informações de bloqueio de caminho rápido de um processo. **LWLock:LogicalRepWorker** Um processo está aguardando para ler ou atualizar o estado dos operadores de replicação lógica. **LWLock:LogicalRepWorkerLock** Um processo está aguardando a conclusão de uma ação em um operador de replicação lógica. **LWLock:LogicalSchemaCache** Um processo modificou o cache do esquema. **LWLock:multixact\$1member** Um processo está aguardando E/S em um buffer multixact\$1member. **LWLock:multixact\$1offset** Um processo está aguardando E/S em um buffer de deslocamento multixact. **LWLock:MultiXactGen** Um processo está aguardando para ler ou atualizar o estado multixact compartilhado. **LWLock:MultiXactGenLock** Um processo está aguardando para ler ou atualizar um estado multixact compartilhado. **LWLock:MultiXactMemberBuffer** Um processo está aguardando a E/S em um buffer simples menos recentemente utilizado (SLRU) para um membro multixact. Para obter mais informações, consulte [LWLock:MultiXact](apg-waits.lwlockmultixact.md). **LWLock:MultiXactMemberControlLock** Um processo está aguardando para ler ou atualizar mapeamentos de membros multixact. **LWLock:MultiXactMemberSLRU** Um processo está aguardando para acessar o cache simples menos recentemente utilizado (SLRU) para um membro multixact. Para obter mais informações, consulte [LWLock:MultiXact](apg-waits.lwlockmultixact.md). **LWLock:MultiXactOffsetBuffer** Um processo está aguardando a E/S em um buffer simples menos recentemente utilizado (SLRU) para um desvio multixact. Para obter mais informações, consulte [LWLock:MultiXact](apg-waits.lwlockmultixact.md). **LWLock:MultiXactOffsetControlLock** Um processo está aguardando para ler ou atualizar mapeamentos de deslocamento multixact. **LWLock:MultiXactOffsetSLRU** Um processo está aguardando para acessar o cache simples menos recentemente utilizado (SLRU) para um desvio multixact. Para obter mais informações, consulte [LWLock:MultiXact](apg-waits.lwlockmultixact.md). **LWLock:MultiXactTruncation** Um processo está aguardando para ler ou truncar informações multixact. **LWLock:MultiXactTruncationLock** Um processo está aguardando para ler ou truncar informações multixact. **LWLock:NotifyBuffer** Um processo está aguardando a E/S no buffer simples menos recentemente utilizado (SLRU) para uma mensagem NOTIFY. **LWLock:NotifyQueue** Um processo está aguardando para ler ou atualizar mensagens NOTIFY. **LWLock:NotifyQueueTail** Um processo está aguardando para atualizar um limite no armazenamento de mensagens NOTIFY. **LWLock:NotifyQueueTailLock** Um processo está aguardando para atualizar o limite no armazenamento de mensagens de notificação. **LWLock:NotifySLRU** Um processo está aguardando para acessar o cache simples menos frequentemente utilizado (SLRU) para uma mensagem NOTIFY. **LWLock:OidGen** Um processo está aguardando para alocar um novo ID de objeto (OID). **LWLock:OidGenLock** Um processo está aguardando para alocar ou atribuir um ID de objeto (OID). **LWLock:oldserxid** Um processo está aguardando E/S em um buffer oldserxid. **LWLock:OldSerXidLock** Um processo está aguardando para ler ou registrar transações serializáveis conflitantes. **LWLock:OldSnapshotTimeMap** Um processo está aguardando para ler ou atualizar informações antigas de controle de snapshots. **LWLock:OldSnapshotTimeMapLock** Um processo está aguardando para ler ou atualizar informações antigas de controle de snapshots. **LWLock:parallel\$1append** Um processo está aguardando para escolher o próximo subplano durante a execução do plano de anexação em paralelo. **LWLock:parallel\$1hash\$1join** Um processo está aguardando para alocar ou trocar um bloco de memória ou atualizar contadores durante a execução de um plano de hash paralelo. **LWLock:parallel\$1query\$1dsa** Um processo está aguardando um bloqueio na alocação de memória compartilhada dinâmica para uma consulta paralela. **LWLock:ParallelAppend** Um processo está aguardando para escolher o próximo subplano durante a execução do plano de anexação em paralelo. **LWLock:ParallelHashJoin** Um processo está aguardando para sincronizar os operadores durante a execução do plano para uma junção de hash paralela. **Lwlock:ParallelQueryDSA** Um processo está aguardando a alocação dinâmica de memória compartilhada para uma consulta paralela. **Lwlock:PerSessionDSA** Um processo está aguardando a alocação dinâmica de memória compartilhada para uma consulta paralela. **Lwlock:PerSessionRecordType** Um processo está aguardando para acessar informações de uma consulta paralela sobre tipos compostos. **Lwlock:PerSessionRecordTypmod** Um processo está aguardando para acessar informações de uma consulta paralela sobre modificadores de tipo que identificam tipos de registros anônimos. **Lwlock:PerXactPredicateList** Um processo está aguardando para acessar a lista de bloqueios de predicados mantidos pela transação serializável atual durante uma consulta paralela. **Lwlock:predicate\$1lock\$1manager** Um processo está aguardando para adicionar ou examinar informações de bloqueio de predicado. **Lwlock:PredicateLockManager** Um processo está aguardando para acessar informações de bloqueio de predicado utilizadas por transações serializáveis. **Lwlock:proc** Um processo está aguardando para ler ou atualizar informações de bloqueio de caminho rápido. **LWLock:ProcArray** Um processo está aguardando para acessar as estruturas de dados compartilhadas por processo (em geral, para obter um snapshot ou relatar o ID da transação de uma sessão). **LWLock:ProcArrayLock** Um processo está aguardando para obter um snapshot ou apagar um ID de transação ao final de uma transação. **LWLock:RelationMapping** Um processo está aguardando para ler ou atualizar um arquivo `pg_filenode.map` (usado para rastrear atribuições de nó de arquivo de determinados catálogos do sistema). **LWLock:RelationMappingLock** Um processo está aguardando para atualizar o arquivo de mapa de relação utilizado para armazenar o mapeamento de catálogo para nó de arquivo. **LWLock:RelCacheInit** Um processo está aguardando para ler ou atualizar um arquivo `pg_internal.init` (um arquivo de inicialização do cache de relação). **LWLock:RelCacheInitLock** Um processo está aguardando para ler ou gravar um arquivo de inicialização do cache de relação. **LWLock:replication\$1origin** Um processo está aguardando para ler ou atualizar o progresso da replicação. **LWLock:replication\$1slot\$1io** Um processo está aguardando E/S em um slot de replicação. **LWLock:ReplicationOrigin** Um processo está aguardando para criar, descartar ou utilizar uma origem de replicação. **LWLock:ReplicationOriginLock** Um processo está aguardando para configurar, descartar ou utilizar uma origem de replicação. **LWLock:ReplicationOriginState** Um processo está aguardando para ler ou atualizar o progresso de uma origem de replicação. **LWLock:ReplicationSlotAllocation** Um processo está aguardando para alocar ou liberar um slot de replicação. **LWLock:ReplicationSlotAllocationLock** Um processo está aguardando para alocar ou liberar um slot de replicação. **LWLock:ReplicationSlotControl** Um processo está aguardando para ler ou atualizar um estado de slot de replicação. **LWLock:ReplicationSlotControlLock** Um processo está aguardando para ler ou atualizar o estado do slot de replicação. **LWLock:ReplicationSlotIO** Um processo está aguardando E/S em um slot de replicação. **LWLock:SerialBuffer** Um processo está aguardando E/S em um buffer simples menos recentemente utilizado (SLRU) para um conflito de transação serializável. **LWLock:SerializableFinishedList** Um processo está aguardando para acessar a lista de transações serializáveis concluídas. **LWLock:SerializableFinishedListLock** Um processo está aguardando para acessar a lista de transações serializáveis concluídas. **LWLock:SerializablePredicateList** Um processo está aguardando para acessar a lista de bloqueios de predicados mantidos por transações serializáveis. **LWLock:SerializablePredicateLockListLock** Um processo está aguardando para executar uma operação em uma lista de bloqueios mantidos por transações serializáveis. **LWLock:SerializableXactHash** Um processo está aguardando para ler ou atualizar informações sobre transações serializáveis. **LWLock:SerializableXactHashLock** Um processo está aguardando para recuperar ou armazenar informações sobre transações serializáveis. **LWLock:SerialSLRU** Um processo está aguardando para acessar o cache simples menos recentemente utilizado (SLRU) para um conflito de transação serializável. **LWLock:SharedTidBitmap** Um processo está aguardando para acessar um bitmap de identificador de tupla compartilhado (TID) durante uma varredura paralela de índice de bitmap. **LWLock:SharedTupleStore** Um processo está aguardando para acessar um armazenamento de tuplas compartilhado durante uma consulta paralela. **LWLock:ShmemIndex** Um processo está aguardando para encontrar ou alocar espaço na memória compartilhada. **LWLock:ShmemIndexLock** Um processo está aguardando para encontrar ou alocar espaço na memória compartilhada. **LWLock:SInvalRead** Um processo está aguardando para recuperar mensagens da fila de anulação de catálogo compartilhado. **LWLock:SInvalReadLock** Um processo está aguardando para recuperar ou remover mensagens de uma fila de invalidação compartilhada. **LWLock:SInvalWrite** Um processo está aguardando para adicionar uma mensagem à fila de anulação de catálogo compartilhada. **LWLock:SInvalWriteLock** Um processo está aguardando para adicionar uma mensagem em uma fila de invalidação compartilhada. **LWLock:SyncRep** Um processo está aguardando para ler ou atualizar informações sobre o estado da replicação síncrona. **LWLock:SyncRepLock** Um processo está aguardando para ler ou atualizar informações sobre réplicas síncronas. **LWLock:SyncScan** Um processo está aguardando para selecionar a localização inicial de uma varredura de tabela sincronizada. **LWLock:SyncScanLock** Um processo está aguardando para obter a localização inicial de uma varredura em uma tabela para varreduras sincronizadas. **LWLock:TablespaceCreate** Um processo está aguardando para criar ou descartar um espaço de tabelas. **LWLock:TablespaceCreateLock** Um processo está aguardando para criar ou descartar o espaço de tabelas. **LWLock:tbm** Um processo está aguardando um bloqueio de iterador compartilhado em um bitmap de árvore (TBM). **LWLock:TwoPhaseState** Um processo está aguardando para ler ou atualizar o estado de transações preparadas. **LWLock:TwoPhaseStateLock** Um processo está aguardando para ler ou atualizar o estado de transações preparadas. **LWLock:wal\$1insert** Um processo está aguardando para inserir o log de gravação antecipada (WAL) em um buffer de memória. **LWLock:WALBufMapping** Um processo está aguardando para substituir uma página em buffers do log de gravação antecipada (WAL). **LWLock:WALBufMappingLock** Um processo está aguardando para substituir uma página em buffers do log de gravação antecipada (WAL). **LWLock:WALInsert** Um processo está aguardando para inserir dados do log de gravação antecipada (WAL) em um buffer de memória. **LWLock:WALWrite** Um processo está aguardando os buffers do log de gravação antecipada (WAL) serem gravados no disco. **LWLock:WALWriteLock** Um processo está aguardando os buffers do log de gravação antecipada (WAL) serem gravados no disco. **LWLock:WrapLimitsVacuum** Um processo está aguardando para atualizar limites sobre o ID de transação e o consumo multixact. **LWLock:WrapLimitsVacuumLock** Um processo está aguardando para atualizar limites sobre o ID de transação e o consumo multixact. **LWLock:XactBuffer** Um processo está aguardando a E/S em um buffer simples menos recentemente utilizado (SLRU) para um status de transação. **LWLock:XactSLRU** Um processo está aguardando para acessar o cache simples menos frequentemente utilizado (SLRU) para um status de transação. **LWLock:XactTruncation** Um processo está aguardando para executar pg\$1xact\$1status ou atualizar o ID de transação mais antigo disponível para ele. **LWLock:XidGen** Um processo está aguardando para alocar um novo ID de transação. **LWLock:XidGenLock** Um processo está aguardando para alocar ou atribuir um ID de transação. **Timeout:BaseBackupThrottle** Um processo está aguardando durante o backup básico ao controlar a utilização da atividade. **Tempo limite:PgSleep** Um processo de backend chamou a função pg\$1sleep e está aguardando o tempo limite de suspensão expirar. Para obter mais informações, consulte [Tempo limite:PgSleep](apg-waits.timeoutpgsleep.md). **Timeout:RecoveryApplyDelay** Um processo está aguardando para aplicar o log de gravação antecipada (WAL) durante a recuperação devido a uma configuração de atraso. **Timeout:RecoveryRetrieveRetryInterval** Um processo está aguardando durante a recuperação quando os dados do log de gravação antecipada (WAL) não estão disponíveis em nenhuma origem (pg\$1wal, arquivo ou fluxo). **Timeout:VacuumDelay** Um processo está aguardando em um ponto de atraso de vacuum baseado em custos. Para obter uma lista completa de eventos de espera do PostgreSQL, consulte [The Statistics Collector > Wait Event tables](https://www.postgresql.org/docs/current/monitoring-stats.html#WAIT-EVENT-TABLE) (Coletor de estatísticas > Tabela de eventos de espera), na documentação do PostgreSQL.