Esta página foi traduzida pela API Cloud Translation.

Melhorar a performance de INSERT SELECT com SELECT paralelo

Usar a execução paralela para a parte SELECT de uma consulta INSERT INTO ... SELECT pode melhorar a performance de consultas do AlloyDB para PostgreSQL, especialmente para tabelas particionadas e consultas complexas.

Ao paralelizar o subplano SELECT, o banco de dados usa vários processos de worker para recuperar dados. Em seguida, o banco de dados insere os dados recuperados na tabela de destino. Essa divisão do trabalho pode levar a melhorias na performance do banco de dados.

Como os planos de consulta paralela funcionam no PostgreSQL

No PostgreSQL, o otimizador de consultas pode criar um plano paralelo para uma consulta inteira ou parte dela. Quando um plano paralelo é gerado, ele adiciona um nó Gather ou Gather Merge à parte de cima do plano.

Esse nó coordena vários processos de worker paralelos. Cada worker executa uma parte da tarefa, por exemplo, a verificação de uma parte de uma tabela. O nó Gather coleta os resultados de todos os workers e os transmite para a próxima etapa da consulta ou de volta ao cliente.

Por exemplo, o plano de consulta a seguir mostra um nó Gather que planeja usar cinco processos de worker para uma verificação sequencial paralela na tabela t1.

EXPLAIN SELECT * FROM t1;

                  QUERY PLAN
-------------------------------------------------------------
 Gather  (cost=0.00..143359.76 rows=9999878 width=60)
   Workers Planned: 5
   ->  Parallel Seq Scan on t1  (cost=0.00..143359.76 rows=1999976 width=60)
(3 rows)

Execução paralela para instruções INSERT...SELECT

O AlloyDB melhora o desempenho do INSERT INTO ... SELECT usando vários processos de worker para paralelizar a instrução SELECT. Essa divisão do trabalho pode levar a melhorias na performance do banco de dados. A consulta precisa ser segura para paralelização e não pode ter condições que impeçam isso.

Muitas operações de banco de dados usam instruções INSERT INTO ... SELECT para adicionar novas linhas a uma tabela. Muitas vezes, a parte SELECT da instrução é a mais intensiva em recursos da consulta.

A funcionalidade é controlada pelos seguintes parâmetros de configuração:

enable_parallel_select_for_insert_select: ativa ou desativa o recurso . Esse parâmetro fica ativado por padrão no PostgreSQL 14 e versões mais recentes.
enable_parallel_select_for_insert_select_into_part_table: ativa ou desativa o recurso que permite inserir em tabelas particionadas. Esse parâmetro fica desativado por padrão no PostgreSQL 16 e versões mais recentes.

Para que o planejador de consultas considere um plano paralelo, a instrução INSERT SELECT precisa ser segura para paralelismo. Isso significa que nenhuma parte da operação pode conter funções ou expressões que não podem ser executadas em paralelo com segurança. Se alguma parte da consulta for considerada não segura para execução paralela, o otimizador vai voltar a um plano não paralelo. Para mais informações, consulte parallel-safety.

Condições que impedem a execução paralela

O otimizador de consultas não usa um plano paralelo se a instrução INSERT SELECT for considerada não segura para execução paralela. As seguintes condições impedem a paralelização:

A tabela de destino é uma tabela externa.
A consulta usa uma expressão de tabela comum (CTE) modificável que contém uma instrução de modificação de dados, por exemplo, DELETE.
Um índice na tabela de destino usa uma expressão ou função paralela não segura.
Uma coluna na tabela de destino tem um valor padrão que usa uma função paralela insegura.
Um gatilho na tabela de destino usa uma expressão ou função paralela não segura.
A tabela de destino tem uma coluna DOMAIN com uma restrição CHECK que usa uma função paralela não segura.
Uma restrição CHECK na tabela de destino contém uma expressão ou função paralela não segura.
A tabela de destino é tabela particionada e enable_parallel_select_for_insert_select_into_part_table está desativado.

Antes de começar

Este documento pressupõe que você tenha um banco de dados do AlloyDB. Para criar um banco de dados, consulte Criar um cluster e a instância principal dele e Criar e gerenciar um banco de dados.

Funções exigidas

Para receber as permissões necessárias para mudar flags de banco de dados no nível da sessão, peça ao administrador para conceder a você o papel de Usuário do banco de dados do AlloyDB (roles/alloydb.databaseUser) do Identity and Access Management (IAM) no seu projeto. Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Ativar parâmetros de execução paralela

Para ativar a execução paralela em tabelas de destino particionadas, siga estas etapas:

No Google Cloud console, acesse a página Clusters.

Acessar Clusters
Selecione um cluster na lista.
No menu de navegação, clique em AlloyDB Studio.
Faça login no AlloyDB Studio usando o nome do banco de dados, o nome de usuário e a senha.

Defina a GUC enable_parallel_select_for_insert_select_into_part_table como on.

SET enable_parallel_select_for_insert_select_into_part_table = on;

Depois de ativar o parâmetro GUC, o planejador de consultas considera automaticamente planos paralelos para instruções INSERT INTO ... SELECT em que o destino é uma tabela particionada, desde que a consulta seja determinada como paralela.

O exemplo a seguir resulta em um plano EXPLAIN que mostra um nó "Gather", o que indica que a SELECT de source_table é executada em paralelo.

-- Create a partitioned table
CREATE TABLE part_table (a INT, b TEXT) PARTITION BY RANGE (a);
CREATE TABLE part_table_1 PARTITION OF part_table FOR VALUES FROM (MINVALUE) TO (1000);
CREATE TABLE part_table_2 PARTITION OF part_table FOR VALUES FROM (1000) TO (MAXVALUE);

-- Create a source table
CREATE TABLE source_table (c1 INT, c2 TEXT);
INSERT INTO source_table SELECT i, 'value_' || i FROM generate_series(1, 2000) i;
ANALYZE source_table;

-- Enable the feature
SET enable_parallel_select_for_insert_select_into_part_table = on;
-- Optional for parallelizing the query with a small amount of data
SET parallel_setup_cost=0;
SET parallel_tuple_cost=0;
SET min_parallel_table_scan_size=0;

-- Run the insert with a parallelizable select
EXPLAIN INSERT INTO part_table SELECT * FROM source_table;

Isso retorna a seguinte saída:

EXPLAIN (COSTS OFF) INSERT INTO part_table SELECT * FROM source_table;
                QUERY PLAN                   
-----------------------------------------------
Insert on part_table
->  Gather
        Workers Planned: 2
        ->  Parallel Seq Scan on source_table
(4 rows)

Desativar parâmetros de execução paralela

Para desativar os parâmetros, siga estas etapas:

No Google Cloud console, acesse a página Clusters.

Acessar Clusters
Selecione um cluster na lista.
No menu de navegação, clique em AlloyDB Studio.
Faça login no AlloyDB Studio usando o nome do banco de dados, o nome de usuário e a senha.
Para desativar o parâmetro enable_parallel_select_for_insert_select, execute o seguinte comando SQL:
```
SET enable_parallel_select_for_insert_select = OFF;
```
Para desativar o parâmetro enable_parallel_select_for_insert_select_into_part_table, execute o seguinte comando SQL:
```
SET enable_parallel_select_for_insert_select_into_part_table = OFF;
```

Verificar um plano paralelo

Para verificar se o otimizador está usando um plano paralelo, use o comando EXPLAIN. Procure um nó Gather e os atributos Workers Planned ou Workers Launched no plano de consulta.

Exemplo de tabela padrão

No exemplo de plano a seguir, seis processos de worker são iniciados para uma junção hash paralela e executar a instrução SELECT.

EXPLAIN (ANALYZE)
INSERT INTO t1 SELECT t2.* FROM t1, t2 WHERE t1.c1 != t2.c1 AND t1.c2 = t2.c2;

                                 QUERY PLAN
------------------------------------------------------------------------------------
 Insert on t1  (cost=1209138.00..12801765.49 rows=0 width=0) (actual time=16812.677..19337.150 rows=0 loops=1)
   ->  Gather  (cost=1209138.00..12801765.49 rows=99995407 width=24) (actual time=16812.674..19337.144 rows=0 loops=1)
         Workers Planned: 6
         Workers Launched: 6
         ->  Parallel Hash Join  (...)
(...)

Exemplo de tabela particionada

O exemplo a seguir mostra que, depois de ativar o recurso para tabelas particionadas, o plano mostra um nó Gather com quatro workers planejados para SELECT.

-- First, enable the feature for partitioned tables
SET enable_parallel_select_for_insert_select_into_part_table = ON;

-- Then, explain the query
EXPLAIN (COSTS OFF) INSERT INTO part_table SELECT * FROM source_table;
                  QUERY PLAN                   
-----------------------------------------------
 Insert on part_table
   ->  Gather
         Workers Planned: 2
         ->  Parallel Seq Scan on source_table
(4 rows)

A seguir

Saiba mais sobre a segurança paralela.

Melhorar a performance de INSERT SELECT com SELECT paralelo Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.