PolarDB:Use o Elastic Parallel Query para consultas analíticas

Funcionamento

Quando uma consulta usa o Elastic Parallel Query, o nó coordenador de consulta (QC) divide o plano de execução em vários shards e os encaminha para nós de execução paralela (PX). Cada nó PX executa seu shard de plano atribuído e retorna os resultados parciais ao nó QC, que os agrega em um resultado final. O nó QC recebe a solicitação inicial da consulta.

No diagrama, RO1 é o nó QC. Ele recebe uma consulta, divide o plano de execução e direciona os shards do plano para três nós PX: RO2, RO3 e RO4. Cada nó PX executa seu shard de plano, lê os blocos de dados necessários do armazenamento compartilhado PolarFS e devolve os resultados ao nó QC. Em seguida, o nó QC agrega esses resultados e retorna a saída final.

Observações de uso

Devido ao alto consumo de recursos, esse recurso é adequado apenas para consultas analíticas pouco frequentes.

Controle granular

Parâmetros

Por padrão, o Elastic Parallel Query vem desativado no PolarDB for PostgreSQL (Compatible with Oracle) e no . Para usar esse recurso, configure os seguintes parâmetros:

SHOW polar_px_nodes ;
 polar_px_nodes
----------------

(1 row)

SET polar_px_nodes='node1,node2';

SHOW polar_px_nodes ;
     polar_px_nodes
    ----------------
     node1,node2
    (1 row)

-- Allows Elastic Parallel Query for table t1.
ALTER TABLE t1 SET(px_workers=1);

-- Disables Elastic Parallel Query for table t1.
ALTER TABLE t1 SET(px_workers=-1);

-- Ignores Elastic Parallel Query for table t1 (default).
ALTER TABLE t1 SET(px_workers=0);

Exemplo

Este exemplo usa uma consulta simples de tabela única para demonstrar o uso do Elastic Parallel Query.

Contexto:

Execute os comandos abaixo para criar uma tabela test e inserir dados de amostra.

CREATE TABLE test(id int);
INSERT INTO test SELECT generate_series(1,1000000);
EXPLAIN SELECT * FROM test;

O Elastic Parallel Query vem desativado por padrão. O plano de execução da consulta exibe um Seq Scan nativo:

                       QUERY PLAN
--------------------------------------------------------
 Seq Scan on test  (cost=0.00..35.50 rows=2550 width=4)
(1 row)

Siga estas etapas para ativar e usar o Elastic Parallel Query:

1. Ative o Elastic Parallel Query para a tabela test.

   ALTER TABLE test SET (px_workers=1);
   SET polar_enable_px=on;
   EXPLAIN SELECT * FROM test;

   O resultado é o seguinte:

                                     QUERY PLAN
   -------------------------------------------------------------------------------
    PX Coordinator 2:1  (slice1; segments: 2)  (cost=0.00..431.00 rows=1 width=4)
      ->  Seq Scan on test (scan partial)  (cost=0.00..431.00 rows=1 width=4)
    Optimizer: PolarDB PX Optimizer
   (3 rows)

2. Consulte os nomes de todos os nós somente leitura atuais.

   Execute o comando a seguir:

   SHOW polar_cluster_map;

   O resultado é o seguinte:

    polar_cluster_map
   -------------------
    node1,node2,node3
   (1 row)

   O resultado mostra que o cluster possui três nós somente leitura: node1, node2 e node3.

3. Especifique que apenas os nós somente leitura node1 e node2 participem do Elastic Parallel Query.

   Execute o comando a seguir:

   SET polar_px_nodes='node1,node2';

   Consulte os nós participantes:

   SHOW polar_px_nodes ;

   O resultado é o seguinte:

    polar_px_nodes
   ----------------
    node1,node2
   (1 row)

Dados de desempenho

Os dados de desempenho a seguir foram registrados em um ambiente de teste com cinco nós somente leitura:

• Em uma varredura completa de tabela (SELECT COUNT(*)), o Elastic Parallel Query foi 60 vezes mais rápido que uma consulta paralela de nó único.

• Para cargas de trabalho TPC-H, o Elastic Parallel Query apresentou velocidade 30 vezes superior à de uma consulta paralela de nó único.

  Nota

  Neste exemplo, implementamos um teste baseado no benchmark TPC-H, mas ele não atende a todos os requisitos de um teste de benchmark TPC-H oficial. Portanto, os resultados podem não ser comparáveis aos resultados publicados do teste de benchmark TPC-H.

Aplicação de controle granular

Esta seção descreve como usar o Elastic Parallel Query em diferentes níveis de granularidade.

• Controle no nível de sistema

  Controle o Elastic Parallel Query no nível do sistema definindo parâmetros GUC globais para ativar o recurso e especificar o grau de paralelismo (DoP).

  Example

  postgres=# alter system set polar_enable_px=1;
  ALTER SYSTEM
  postgres=# alter system set polar_px_dop_per_node=1;
  ALTER SYSTEM
  postgres=# select pg_reload_conf();
   pg_reload_conf
  ----------------
   t
  (1 row)
  postgres=# \c postgres
  You are now connected to database "postgres" as user "postgres".
  
  postgres=# drop table if exists t1;
  DROP TABLE
  postgres=# select id into t1 from generate_series(1, 1000) as id order by id desc;
  SELECT 1000
  postgres=# alter table t1 set (px_workers=1);
  ALTER TABLE
  postgres=# explain (verbose, costs off)   select * from t1 where id < 10;
                  QUERY PLAN
  -------------------------------------------
   PX Coordinator 2:1  (slice1; segments: 2)
     Output: id
     ->  Partial Seq Scan on public.t1
           Output: id
           Filter: (t1.id < 10)
   Optimizer: PolarDB PX Optimizer
  (6 rows)

• Controle no nível de sessão

  Gerencie o Elastic Parallel Query para a sessão atual usando a sintaxe ALTER SESSION ou definindo parâmetros GUC no nível de sessão.

  • Sintaxe ALTER SESSION

    ALTER SESSION ENABLE PARALLEL QUERY
    ALTER SESSION DISABLE PARALLEL QUERY
    ALTER SESSION FORCE PARALLEL QUERY [PARALLEL integer]

    Nota

    • ALTER SESSION ENABLE PARALLEL QUERY permite que a sessão atual use hints ou sintaxe paralela para ativar consultas paralelas.

    • ALTER SESSION DISABLE PARALLEL QUERY força a sessão atual a usar execução serial. Consultas paralelas são desativadas e quaisquer hints ou sintaxes paralelas são ignorados.

    • ALTER SESSION FORCE PARALLEL QUERY [PARALLEL integer] obriga a sessão atual a usar execução paralela. Opcionalmente, especifique o grau de paralelismo (DoP) com PARALLEL integer. Se omitido, o sistema usa o DoP do parâmetro polar_px_dop_per_node.

      O DoP final é determinado pela seguinte ordem de prioridade: hint > cláusula FORCE PARALLEL > parâmetro polar_px_dop_per_node.

    Este comando afeta apenas a sessão atual e é redefinido após reconexão. O valor padrão é enable.

    Example

    --enable
    postgres=# set polar_enable_px = false;
    SET
    postgres=# set polar_px_enable_hint = true;
    SET
    postgres=# alter session enable parallel query;
    ALTER SESSION
    
    postgres=# explain (verbose, costs off)   select /*+ PARALLEL(4)*/ * from t1 where id < 10;
    INFO:  [HINTS] PX PARALLEL(4) accepted.
                    QUERY PLAN
    -------------------------------------------
     PX Coordinator 8:1  (slice1; segments: 8)
       Output: id
       ->  Partial Seq Scan on public.t1
             Output: id
             Filter: (t1.id < 10)
     Optimizer: PolarDB PX Optimizer
    (6 rows)

    --disable
    postgres=# set polar_enable_px = false;
    SET
    postgres=# set polar_px_enable_hint = true;
    SET
    postgres=# alter session disable parallel query;
    ALTER SESSION
    
    postgres=# explain (verbose, costs off)   select /*+ PARALLEL(4)*/ * from t1 where id < 10;
           QUERY PLAN
    ------------------------
     Seq Scan on public.t1
       Output: id
       Filter: (t1.id < 10)
    (3 rows)

    --force
    postgres=# set polar_enable_px = false;
    SET
    postgres=# set polar_px_enable_hint = false;
    SET
    postgres=# alter session force parallel query;
    ALTER SESSION
    
    postgres=# explain (verbose, costs off)   select * from t1 where id < 10;
               QUERY PLAN
    -------------------------------------------
     PX Coordinator 2:1  (slice1; segments: 2)
       Output: id
       ->  Partial Seq Scan on public.t1
             Output: id
             Filter: (t1.id < 10)
     Optimizer: PolarDB PX Optimizer
    (6 rows)
    
    postgres=# alter session force parallel query parallel 2;
    ALTER SESSION
    postgres=# explain (verbose, costs off)   select * from t1 where id < 10;
                    QUERY PLAN
    -------------------------------------------
     PX Coordinator 4:1  (slice1; segments: 4)
       Output: id
       ->  Partial Seq Scan on public.t1
             Output: id
             Filter: (t1.id < 10)
     Optimizer: PolarDB PX Optimizer
    (6 rows)

  • Controle via parâmetro GUC

    Como os parâmetros GUC podem ser definidos tanto no nível de sistema quanto no de sessão, use-os também para controlar o comportamento de uma sessão específica.

    Example

    postgres=# set polar_enable_px = true;
    SET
    postgres=# set polar_px_dop_per_node = 1;
    SET
    postgres=# explain (verbose, costs off)   select * from t1 where id < 10;
                    QUERY PLAN
    -------------------------------------------
     PX Coordinator 2:1  (slice1; segments: 2)
       Output: id
       ->  Partial Seq Scan on public.t1
             Output: id
             Filter: (t1.id < 10)
     Optimizer: PolarDB PX Optimizer
    (6 rows)

• Controle no nível de consulta

  Use uma hint SQL para controlar se uma consulta específica usa o Elastic Parallel Query e para definir seu grau de paralelismo (DoP). A sintaxe da hint é a seguinte:

  /*+ PARALLEL(DEFAULT) */
  /*+ PARALLEL(integer) */
  /*+ NO_PARALLEL(tablename) */

  Nota

  • PARALLEL(DEFAULT) determina que a consulta use o Elastic Parallel Query com o grau de paralelismo padrão definido pelo parâmetro polar_px_dop_per_node.

  • PARALLEL(integer) define que a consulta use o Elastic Parallel Query com o grau de paralelismo especificado.

  • NO_PARALLEL(tablename) impede que a tabela especificada seja consultada em paralelo. Se uma consulta incluir essa tabela, toda a consulta será executada serialmente.

  • Para compatibilidade com Oracle, aplicam-se as seguintes regras ao misturar hints paralelas:

    • Em múltiplos blocos de hint, como /+ A / /+ B / /+ C /, apenas o primeiro bloco tem efeito.

    • Se várias hints paralelas forem usadas em um único bloco, como /+ parallel(A) parallel(B) /, e os valores de DoP forem diferentes, haverá conflito e todas as hints paralelas serão ignoradas. Se os valores forem iguais, a hint será aplicada.

    • Caso uma hint parallel e uma hint no_parallel apareçam no mesmo bloco, como /+ parallel(A) no_parallel(t1) /, a hint no_parallel será ignorada.

  • Atualmente, apenas as hints parallel e no_parallel têm suporte para consultas paralelas.

  • Para usar hints no controle em nível de consulta, defina o parâmetro GUC polar_px_enable_hint como true. Por padrão, ele é false.

  Example

  postgres=# set polar_enable_px = false;
  SET
  postgres=# set polar_px_dop_per_node = 1;
  SET
  postgres=# set polar_px_enable_hint = true;
  SET
  postgres=# explain (verbose, costs off)   select * from t1 where id < 10;
         QUERY PLAN
  ------------------------
   Seq Scan on public.t1
     Output: id
     Filter: (t1.id < 10)
  (3 rows)
  
  postgres=# explain (verbose, costs off)   select /*+ PARALLEL(DEFAULT) */ * from t1 where id < 10;
                  QUERY PLAN
  -------------------------------------------
   PX Coordinator 2:1  (slice1; segments: 2)
     Output: id
     ->  Partial Seq Scan on public.t1
           Output: id
           Filter: (t1.id < 10)
   Optimizer: PolarDB PX Optimizer
  (6 rows)
  
  postgres=# explain (verbose, costs off)   select /*+ PARALLEL(4) */ * from t1 where id < 10;
                  QUERY PLAN
  -------------------------------------------
   PX Coordinator 8:1  (slice1; segments: 8)
     Output: id
     ->  Partial Seq Scan on public.t1
           Output: id
           Filter: (t1.id < 10)
   Optimizer: PolarDB PX Optimizer
  (6 rows)
  
  postgres=# explain (verbose, costs off)   select /*+ PARALLEL(0) */ * from t1 where id < 10;
         QUERY PLAN
  ------------------------
   Seq Scan on public.t1
     Output: id
     Filter: (t1.id < 10)
  (3 rows)
  
  postgres=# explain (verbose, costs off)   select /*+ NO_PARALLEL(t1) */ * from t1 where id < 10;
         QUERY PLAN
  ------------------------
   Seq Scan on public.t1
     Output: id
     Filter: (t1.id < 10)
  (3 rows)

• Efeitos combinados dos diferentes níveis

  Ao combinar configurações de diferentes níveis, o comportamento final segue as regras abaixo:

  Nível de sistema		Nível de sessão	Nível de consulta	Resultado
  polar_enable_px=on	polar_px_dop_per_node=X	enable	Sem hint	Paralelo, DoP X
  polar_enable_px=on	polar_px_dop_per_node=X	enable	PARALLEL(Y)	Paralelo, DoP Y
  polar_enable_px=on	polar_px_dop_per_node=X	enable	NO_PARALLEL	Serial
  polar_enable_px=on	polar_px_dop_per_node=X	disable	Sem hint	Serial
  polar_enable_px=on	polar_px_dop_per_node=X	disable	PARALLEL(Y)	Serial
  polar_enable_px=on	polar_px_dop_per_node=X	disable	NO_PARALLEL	Serial
  polar_enable_px=on	polar_px_dop_per_node=X	FORCE PARALLEL Z	Sem hint	Paralelo, DoP Z
  polar_enable_px=on	polar_px_dop_per_node=X	FORCE PARALLEL Z	PARALLEL(Y)	Paralelo, DoP Y
  polar_enable_px=on	polar_px_dop_per_node=X	FORCE PARALLEL Z	NO_PARALLEL	Serial
  polar_enable_px=off	polar_px_dop_per_node=X	enable	Sem hint	Serial
  polar_enable_px=off	polar_px_dop_per_node=X	enable	PARALLEL(Y)	Paralelo, DoP Y
  polar_enable_px=off	polar_px_dop_per_node=X	enable	NO_PARALLEL	Serial
  polar_enable_px=off	polar_px_dop_per_node=X	disable	Sem hint	Serial
  polar_enable_px=off	polar_px_dop_per_node=X	disable	PARALLEL(Y)	Serial
  polar_enable_px=off	polar_px_dop_per_node=X	disable	NO_PARALLEL	Serial
  polar_enable_px=off	polar_px_dop_per_node=X	FORCE PARALLEL Z	Sem hint	Paralelo, DoP Z
  polar_enable_px=off	polar_px_dop_per_node=X	FORCE PARALLEL Z	PARALLEL(Y)	Paralelo, DoP Y
  polar_enable_px=off	polar_px_dop_per_node=X	FORCE PARALLEL Z	NO_PARALLEL	Serial