parallel hints syntax for PolarDB for MySQL - PolarDB: Central de Documentação do Alibaba Cloud

Compatibilidade de versões

Versão	Hints suportados
PolarDB for MySQL 8.0.1	`PARALLEL`, `NO_PARALLEL`
PolarDB for MySQL 8.0.2	`PARALLEL`, `NO_PARALLEL`, `PQ_DISTRIBUTE`, `PQ_GROUPBY`, `PQ_DISTINCT`, `PQ_WINDOW`, `PQ_ORDERBY`

A versão 8.0.2 adiciona o hint PQ_DISTRIBUTE para distribuição de junções, além dos hints PQ_GROUPBY, PQ_DISTINCT, PQ_WINDOW e PQ_ORDERBY para definir os modos de execução de agregação e ordenação.

Referência rápida

Hint	Finalidade	Versão
`PARALLEL`	Ativa a consulta paralela; defina o DOP ou as tabelas-alvo	8.0.1+
`NO_PARALLEL`	Desativa a consulta paralela globalmente ou para tabelas específicas	8.0.1+
`PQ_DISTRIBUTE`	Defina o método de distribuição para junções	8.0.2
`PQ_GROUPBY`	Defina o modo de execução da agregação GROUP BY	8.0.2
`PQ_DISTINCT`	Defina o modo de execução da agregação DISTINCT	8.0.2
`PQ_WINDOW`	Defina o modo de execução de funções de janela	8.0.2
`PQ_ORDERBY`	Defina o modo de ordenação ORDER BY	8.0.2
`PQ_PUSHDOWN`	Execute subconsultas em paralelo usando a política de pushdown	-
`NO_PQ_PUSHDOWN`	Execute subconsultas em paralelo usando a política de acesso compartilhado	-

Ative ou desative consulta paralela

Ative

SELECT /*+PARALLEL(x)*/ ... FROM ...;   -- x > 0
SELECT /*+ SET_VAR(max_parallel_degree=n) */ * FROM ...   -- n > 0

Desative

SELECT /*+NO_PARALLEL()*/ ... FROM ...;
SELECT /*+ SET_VAR(max_parallel_degree=0) */ * FROM ...

PARALLEL e NO_PARALLEL

Especifique tabelas para varredura paralela ou exclua tabelas específicas desse tipo de processamento.

Sintaxe

/*+ PARALLEL [( [query_block] [table_name] [degree] )] */
/*+ NO_PARALLEL [( [query_block] [table_name][, table_name] )] */

Parâmetros

Parâmetro	Descrição
`query_block`	Nome do bloco de consulta ao qual o hint se aplica.
`table_name`	Nome da tabela à qual o hint se aplica.
`degree`	Grau de paralelismo (DOP).

Nota

O hint PARALLEL não surte efeito em consultas que não suportam processamento paralelo ou em tabelas incompatíveis com varreduras paralelas.

PARALLEL() vs SET_VAR

Ambos definem o DOP, mas diferem na forma de imposição:

**PARALLEL()**: força a execução paralela mesmo quando a contagem de linhas da tabela está abaixo de records_threshold_for_parallelism (padrão: 10.000).
**SET_VAR(max_parallel_degree=n): defina o DOP, mas não** força a execução paralela se a contagem de linhas da tabela for inferior a records_threshold_for_parallelism.

Use PARALLEL() para garantir a execução paralela independentemente do tamanho da tabela. Use SET_VAR para permitir que o otimizador decida com base na contagem de linhas.

Exemplos

Forçar consulta paralela com DOP padrão

SELECT /*+PARALLEL()*/ * FROM t1, t2;

Força a execução paralela mesmo quando a contagem de linhas está abaixo de records_threshold_for_parallelism (padrão: 10000). O DOP é determinado por max_parallel_degree. Se max_parallel_degree for 0, a consulta paralela será desativada.

Forçar consulta paralela com um DOP específico

SELECT /*+PARALLEL(8)*/ * FROM t1, t2;

Impõe a execução paralela com DOP 8, inclusive quando a contagem de linhas for menor que records_threshold_for_parallelism.

Definir DOP via SET_VAR

SELECT /*+ SET_VAR(max_parallel_degree=8) */ * FROM t1, t2;

Defina max_parallel_degree como 8. Diferentemente de PARALLEL(), este comando não força a execução paralela quando a contagem de linhas está abaixo de records_threshold_for_parallelism.

Varredura paralela em uma tabela específica

SELECT /*+PARALLEL(t1)*/ * FROM t1, t2;

Força a varredura paralela apenas na tabela t1.

SELECT /*+PARALLEL(t1 8)*/ * FROM t1, t2;

Execute varredura paralela em t1 com DOP igual a 8.

Subconsultas paralelas usando blocos de consulta

SELECT /*+PARALLEL(@subq1)*/ SUM(t.a) FROM t WHERE t.a =
  (SELECT /*+QB_NAME(subq1)*/ SUM(t1.a) FROM t1);

Força a execução paralela para o bloco de consulta nomeado subq1, utilizando o valor padrão de max_parallel_degree para o DOP.

SELECT /*+PARALLEL(@subq1 8)*/ SUM(t.a) FROM t WHERE t.a =
  (SELECT /*+QB_NAME(subq1)*/ SUM(t1.a) FROM t1);

Impõe execução paralela ao bloco de consulta subq1 com DOP de 8.

Subconsultas paralelas usando hints inline

SELECT SUM(t.a) FROM t WHERE t.a =
  (SELECT /*+PARALLEL()*/ SUM(t1.a) FROM t1);

Força a execução paralela da subconsulta usando o valor padrão de max_parallel_degree.

SELECT SUM(t.a) FROM t WHERE t.a =
  (SELECT /*+PARALLEL(8)*/ SUM(t1.a) FROM t1);

Execute a subconsulta em paralelo com DOP definido em 8.

Desativar consulta paralela

SELECT /*+NO_PARALLEL()*/ * FROM t1, t2;

Desativa a consulta paralela para toda a instrução.

Desativar consulta paralela para tabelas específicas

SELECT /*+NO_PARALLEL(t1)*/ * FROM t1, t2;

Desativa varreduras paralelas somente para t1. Caso a consulta paralela esteja ativada, o sistema ainda poderá executar varreduras paralelas em t2.

SELECT /*+NO_PARALLEL(t1, t2)*/ * FROM t1, t2;

Bloqueia varreduras paralelas tanto em t1 quanto em t2.

Desativar subconsultas paralelas

SELECT /*+NO_PARALLEL(@subq1)*/ SUM(t.a) FROM t WHERE t.a =
  (SELECT /*+QB_NAME(subq1)*/ SUM(t1.a) FROM t1);

SELECT SUM(t.a) FROM t WHERE t.a =
  (SELECT /*+NO_PARALLEL()*/ SUM(t1.a) FROM t1);

Ambas as instruções desativam a execução paralela para a subconsulta.

PQ_DISTRIBUTE (operações de junção)

Controle como os dados são distribuídos durante junções paralelas. Este recurso suporta distribuição de tabela única e distribuição de junção entre duas tabelas.

Sintaxe

Distribuição de tabela única:

/*+ PQ_DISTRIBUTE([query_block] table_name strategy) */

Distribuição de junção entre duas tabelas — defina o modo de junção entre table_name e a tabela anterior:

/*+ PQ_DISTRIBUTE([query_block] table_name strategy1 [strategy2]) */

Se apenas strategy1 for especificada, a distribuição aplica-se a table_name. Quando ambas strategy1 e strategy2 estão presentes, elas definem a distribuição da junção entre table_name e a tabela anterior.

Nota

A tabela anterior pode ser uma tabela física ou uma tabela intermediária resultante de uma operação de junção prévia.

Parâmetros

Parâmetro	Descrição
`query_block`	Nome do bloco de consulta ao qual o hint se aplica.
`table_name`	Nome da tabela à qual o hint se aplica.
`strategy`	Método de distribuição. Consulte os valores válidos abaixo.

Valores de estratégia

Estratégia	Descrição
`PQ_GATHER`	Agrega dados em um worker da fase anterior.
`PQ_HASH`	Embaralha e distribui dados para múltiplos workers da fase anterior.
`PQ_BROADCAST`	Transmite dados para múltiplos workers da fase anterior.
`PQ_NONE`	Não distribui dados.

Exemplos

Distribuição de tabela única

SELECT /*+ PARALLEL(t1) PQ_DISTRIBUTE(t1 PQ_GATHER) */ * FROM t AS t1;

Varre t1 em paralelo. Os resultados são coletados pelo líder sem redistribuição.

SELECT /*+ PARALLEL(t1) PQ_DISTRIBUTE(t1 PQ_HASH) */ t1.a, SUM(t1.b) FROM t AS t1 GROUP BY t1.a;

Realiza varredura paralela em t1 e distribui os dados via hash para os workers da próxima fase, com base na chave de agrupamento.

Distribuição de junção entre duas tabelas

SELECT /*+ PARALLEL(t1) PARALLEL(t2) PQ_DISTRIBUTE(t2 PQ_HASH PQ_HASH) */ *
FROM t AS t1 STRAIGHT_JOIN t AS t2 ON t1.b = t2.c;

Ambas as tabelas são varridas em paralelo e os dados são distribuídos via hash para os workers da próxima fase, permitindo uma junção colocalizada. O líder coleta os resultados finais.

SELECT /*+ PARALLEL(t1) PARALLEL(t2) PQ_DISTRIBUTE(t2 PQ_GATHER PQ_GATHER) */ *
FROM t AS t1 STRAIGHT_JOIN t AS t2 ON t1.b = t2.c;

As duas tabelas passam por varredura paralela e os dados são consolidados pelo líder, que conclui a junção.

Estratégias conflitantes

SELECT /*+ PARALLEL(t1) PARALLEL(t2) PQ_DISTRIBUTE(t2 PQ_HASH PQ_GATHER) */ *
FROM t AS t1 STRAIGHT_JOIN t AS t2 ON t1.b = t2.c;

Há conflito entre as estratégias (PQ_HASH para t1 e PQ_GATHER para t2), impossibilitando a geração de um plano de consulta paralela.

PQ_GROUPBY (agregação GROUP BY)

Defina o modo de execução paralela para agregações GROUP BY.

Sintaxe

/*+ PQ_GROUPBY(strategy) */

Valores de estratégia

Estratégia	Descrição
`PQ_ONEPHASE`	Distribui dados aos workers pela chave de agrupamento. Os workers realizam a agregação em paralelo.
`PQ_TWOPHASE_GATHER`	Cada worker agrega separadamente. O líder mescla os resultados parciais no resultado final.
`PQ_TWOPHASE_HASH`	Cada worker agrega separadamente e depois distribui os dados aos workers da próxima fase pela chave de agrupamento para a agregação final.
`PQ_SERIAL`	Execute a agregação GROUP BY serialmente.

Exemplos

SELECT /*+ PARALLEL(t1) PQ_GROUPBY(PQ_ONEPHASE) */ t1.a, SUM(t1.b) FROM t AS t1 GROUP BY t1.a;

Varre t1 em paralelo e distribui os dados aos workers da próxima fase com base em t1.a. Os workers agregam em paralelo e o líder coleta os resultados.

SELECT /*+ PARALLEL(t1) PQ_GROUPBY(PQ_TWOPHASE_HASH) */ t1.a, SUM(t1.b) FROM t AS t1 GROUP BY t1.a;

Os workers varrem t1 em paralelo e agregam localmente. Os resultados intermediários são redistribuídos por t1.a para a agregação final. O líder consolida os resultados.

PQ_DISTINCT (agregação DISTINCT)

Defina o modo de execução paralela para operações DISTINCT.

Sintaxe

/*+ PQ_DISTINCT(strategy) */

Valores de estratégia

Estratégia	Descrição
`PQ_TWOPHASE_GATHER`	Cada worker agrega separadamente. O líder mescla os resultados parciais no resultado final.
`PQ_SERIAL`	Execute a agregação DISTINCT serialmente.

PQ_WINDOW (funções de janela)

Defina o modo de execução paralela para funções de janela.

Sintaxe

/*+ PQ_WINDOW([window_name] strategy) */

Nota

Um hint que especifique um window_name tem prioridade sobre um hint sem essa especificação.

Parâmetros

Parâmetro	Descrição
`window_name`	Função de janela à qual a estratégia será aplicada. Se omitido, a estratégia aplica-se a todas as funções de janela.
`strategy`	Modo de execução. Consulte os valores válidos abaixo.

Valores de estratégia

Estratégia	Descrição
`PQ_ONEPHASE`	Distribui dados conforme a cláusula PARTITION BY. Os workers calculam a função de janela em paralelo.
`PQ_SERIAL`	Execute o cálculo da função de janela serialmente.

Exemplo

SELECT /*+ PQ_WINDOW(PQ_ONEPHASE) PQ_WINDOW(win PQ_SERIAL) */
  ROW_NUMBER() OVER(win) AS 'row_number',
  RANK() OVER(PARTITION BY name ORDER BY salary DESC)
FROM employee_salaries WINDOW win AS (PARTITION BY dept ORDER BY salary DESC);

A janela nomeada win executa serialmente. Todas as outras funções de janela são distribuídas aos workers pela chave PARTITION BY para computação paralela.

PQ_ORDERBY (ordenação)

Defina o modo de execução paralela para ordenações ORDER BY.

Sintaxe

/*+ PQ_ORDERBY(strategy) */

Valores de estratégia

Estratégia	Descrição
`PQ_TWOPHASE_GATHER`	Os workers ordenam os dados em paralelo. O líder mescla os resultados parciais no resultado ordenado final.
`PQ_SERIAL`	Execute a ordenação serialmente.

PQ_PUSHDOWN e NO_PQ_PUSHDOWN (subconsultas paralelas)

Defina a política de execução paralela para subconsultas. Os detalhes sobre o suporte a subconsultas estão documentados em Visualize planos de execução de consulta paralela.

Sintaxe

/*+ PQ_PUSHDOWN [( [query_block])] */       -- Pushdown policy
/*+ NO_PQ_PUSHDOWN [( [query_block])] */    -- Shared access policy

Exemplos

Política de pushdown:

EXPLAIN SELECT /*+ PQ_PUSHDOWN(@qb1) */ * FROM t2 WHERE t2.a =
                 (SELECT /*+ QB_NAME(qb1) */ a FROM t1);

Política de acesso compartilhado:

EXPLAIN SELECT /*+ NO_PQ_PUSHDOWN(@qb1) */ * FROM t2 WHERE t2.a =
                 (SELECT /*+ QB_NAME(qb1) */ a FROM t1);

Hint inline sem referência a bloco de consulta:

EXPLAIN SELECT * FROM t2 WHERE t2.a =
                 (SELECT /*+ NO_PQ_PUSHDOWN() */ a FROM t1);