parallel hints syntax for PolarDB for MySQL - PolarDB - Centro de documentación de Alibaba Cloud

Utilice los hints de paralelismo para anular el optimizador y controlar el grado de paralelismo (DOP), el comportamiento del escaneo de tablas y las estrategias de distribución en operaciones join, agregaciones y ordenamientos.

Compatibilidad de versiones

Versión	Hints compatibles
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`

La versión 8.0.2 incorpora PQ_DISTRIBUTE para la distribución de joins. También añade PQ_GROUPBY, PQ_DISTINCT, PQ_WINDOW y PQ_ORDERBY para definir los modos de ejecución de agregaciones y ordenamientos.

Referencia rápida

Hint	Propósito	Versión
`PARALLEL`	Habilitar consultas en paralelo; establecer el DOP o las tablas de destino	8.0.1+
`NO_PARALLEL`	Deshabilitar consultas en paralelo de forma global o para tablas específicas	8.0.1+
`PQ_DISTRIBUTE`	Establecer el método de distribución para operaciones join	8.0.2
`PQ_GROUPBY`	Establecer el modo de ejecución de la agregación GROUP BY	8.0.2
`PQ_DISTINCT`	Establecer el modo de ejecución de la agregación DISTINCT	8.0.2
`PQ_WINDOW`	Establecer el modo de ejecución de funciones de ventana	8.0.2
`PQ_ORDERBY`	Establecer el modo de ordenamiento ORDER BY	8.0.2
`PQ_PUSHDOWN`	Ejecutar subconsultas en paralelo mediante la directiva pushdown	-
`NO_PQ_PUSHDOWN`	Ejecutar subconsultas en paralelo mediante la directiva de acceso compartido	-

Habilitar o deshabilitar consultas en paralelo

Habilitar

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

Deshabilitar

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

PARALLEL y NO_PARALLEL

Especifique las tablas que se escanearán en paralelo o excluya tablas específicas de los escaneos paralelos.

Sintaxis

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

Parámetros

Parámetro	Descripción
`query_block`	Nombre del bloque de consulta al que aplica el hint.
`table_name`	Nombre de la tabla a la que aplica el hint.
`degree`	Grado de paralelismo (DOP).

Nota

El hint PARALLEL no surte efecto en consultas que no admiten procesamiento paralelo ni en tablas incompatibles con escaneos paralelos.

PARALLEL() frente a SET_VAR

Ambos establecen el DOP, pero difieren en su aplicación:

**PARALLEL()** fuerza la ejecución en paralelo incluso cuando el número de filas de la tabla es menor que records_threshold_for_parallelism (valor predeterminado: 10,000).
**SET_VAR(max_parallel_degree=n) establece el DOP, pero no** fuerza la ejecución en paralelo si el número de filas de la tabla es menor que records_threshold_for_parallelism.

Utilice PARALLEL() para garantizar la ejecución en paralelo sin importar el tamaño de la tabla. Utilice SET_VAR para permitir que el optimizador decida según el número de filas.

Ejemplos

Forzar una consulta en paralelo con el DOP predeterminado

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

Fuerza la ejecución en paralelo aunque el número de filas sea menor que records_threshold_for_parallelism (valor predeterminado: 10000). El valor de max_parallel_degree determina el DOP. Si max_parallel_degree es 0, la consulta en paralelo se deshabilita.

Forzar una consulta en paralelo con un DOP específico

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

Fuerza la ejecución en paralelo con un DOP de 8, incluso si el número de filas es menor que records_threshold_for_parallelism.

Establecer el DOP mediante SET_VAR

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

Establece max_parallel_degree en 8. A diferencia de PARALLEL(), no fuerza la ejecución en paralelo cuando el número de filas es menor que records_threshold_for_parallelism.

Escaneo paralelo en una tabla específica

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

Fuerza el escaneo paralelo únicamente en t1.

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

Fuerza el escaneo paralelo en t1 con un DOP de 8.

Subconsultas en paralelo mediante bloques de consulta

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

Fuerza la ejecución en paralelo para el bloque de consulta llamado subq1. Utiliza el valor predeterminado de max_parallel_degree como DOP.

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

Fuerza la ejecución en paralelo para el bloque de consulta subq1 con un DOP de 8.

Subconsultas en paralelo mediante hints en línea

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

Fuerza la ejecución en paralelo para la subconsulta con el valor predeterminado de max_parallel_degree.

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

Fuerza la ejecución en paralelo para la subconsulta con un DOP de 8.

Deshabilitar consultas en paralelo

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

Deshabilita las consultas en paralelo para toda la instrucción.

Deshabilitar consultas en paralelo para tablas específicas

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

Deshabilita los escaneos paralelos solo para t1. Si las consultas en paralelo están habilitadas, el sistema aún podría ejecutar escaneos paralelos en t2.

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

Deshabilita los escaneos paralelos tanto para t1 como para t2.

Deshabilitar subconsultas en paralelo

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 instrucciones deshabilitan la ejecución en paralelo para la subconsulta.

PQ_DISTRIBUTE (operaciones join)

Controle cómo se distribuyen los datos durante las operaciones join en paralelo. Admite la distribución de una sola tabla y la distribución de joins entre dos tablas.

Sintaxis

Distribución de una sola tabla:

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

Distribución de joins entre dos tablas: establece el modo de join entre table_name y la tabla anterior.

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

Si solo se especifica strategy1, la distribución aplica a table_name. Cuando se indican strategy1 y strategy2, ambas definen la distribución del join entre table_name y la tabla anterior.

Nota

La tabla anterior puede ser una tabla física o una tabla intermedia generada por una operación join previa.

Parámetros

Parámetro	Descripción
`query_block`	Nombre del bloque de consulta al que aplica el hint.
`table_name`	Nombre de la tabla a la que aplica el hint.
`strategy`	Método de distribución. Consulte los valores válidos más adelante.

Valores de estrategia

Estrategia	Descripción
`PQ_GATHER`	Agrega los datos en un worker de la fase anterior.
`PQ_HASH`	Reorganiza y distribuye los datos entre varios workers de la fase anterior.
`PQ_BROADCAST`	Transmite los datos a varios workers de la fase anterior.
`PQ_NONE`	No distribuye los datos.

Ejemplos

Distribución de una sola tabla

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

Escanea t1 en paralelo. El nodo líder recopila los resultados sin redistribuirlos.

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

Escanea t1 en paralelo y distribuye los datos por hash a los workers de la siguiente fase según la clave de agrupación.

Distribución de joins entre dos tablas

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 tablas se escanean en paralelo. Los datos se distribuyen por hash a los workers de la siguiente fase para ejecutar un join ubicado en el mismo lugar (collocated join). El nodo líder recopila los resultados finales.

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;

Ambas tablas se escanean en paralelo. El nodo líder recopila los datos y completa el join.

Estrategias en conflicto

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;

Las estrategias entran en conflicto (PQ_HASH para t1 y PQ_GATHER para t2), por lo que no se genera ningún plan de consulta en paralelo.

PQ_GROUPBY (agregación GROUP BY)

Controle el modo de ejecución en paralelo para las agregaciones GROUP BY.

Sintaxis

/*+ PQ_GROUPBY(strategy) */

Valores de estrategia

Estrategia	Descripción
`PQ_ONEPHASE`	Distribuye los datos entre los workers según la clave de agrupación. Los workers ejecutan la agregación en paralelo.
`PQ_TWOPHASE_GATHER`	Cada worker realiza la agregación por separado. El nodo líder combina los resultados parciales para generar el resultado final.
`PQ_TWOPHASE_HASH`	Cada worker realiza la agregación por separado. Después, distribuye los datos a los workers de la siguiente fase según la clave de agrupación para la agregación final.
`PQ_SERIAL`	Ejecuta la agregación GROUP BY de forma secuencial.

Ejemplos

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

Escanea t1 en paralelo y distribuye los datos a los workers de la siguiente fase según t1.a. Los workers ejecutan la agregación en paralelo y el nodo líder recopila los resultados.

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

Los workers escanean t1 en paralelo y realizan la agregación local. Los resultados intermedios se redistribuyen según t1.a para la agregación final. El nodo líder recopila los resultados.

PQ_DISTINCT (agregación DISTINCT)

Controle el modo de ejecución en paralelo para las operaciones DISTINCT.

Sintaxis

/*+ PQ_DISTINCT(strategy) */

Valores de estrategia

Estrategia	Descripción
`PQ_TWOPHASE_GATHER`	Cada worker realiza la agregación por separado. El nodo líder combina los resultados parciales para generar el resultado final.
`PQ_SERIAL`	Ejecuta la agregación DISTINCT de forma secuencial.

PQ_WINDOW (funciones de ventana)

Controle el modo de ejecución en paralelo para las funciones de ventana.

Sintaxis

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

Nota

Un hint que especifica un window_name tiene prioridad sobre uno que no lo incluye.

Parámetros

Parámetro	Descripción
`window_name`	Función de ventana a la que se aplica la estrategia. Si se omite, la estrategia aplica a todas las funciones de ventana.
`strategy`	Modo de ejecución. Consulte los valores válidos más adelante.

Valores de estrategia

Estrategia	Descripción
`PQ_ONEPHASE`	Distribuye los datos según la cláusula PARTITION BY. Los workers calculan la función de ventana en paralelo.
`PQ_SERIAL`	Calcula la función de ventana de forma secuencial.

Ejemplo

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);

La ventana llamada win se ejecuta de forma secuencial. Las demás funciones de ventana se distribuyen entre los workers según la clave PARTITION BY para calcularse en paralelo.

PQ_ORDERBY (ordenamiento)

Controle el modo de ejecución en paralelo para el ordenamiento ORDER BY.

Sintaxis

/*+ PQ_ORDERBY(strategy) */

Valores de estrategia

Estrategia	Descripción
`PQ_TWOPHASE_GATHER`	Los workers ordenan los datos en paralelo. El nodo líder combina los resultados parciales para generar el resultado ordenado final.
`PQ_SERIAL`	Ordena los datos de forma secuencial.

PQ_PUSHDOWN y NO_PQ_PUSHDOWN (subconsultas en paralelo)

Controle la directiva de ejecución en paralelo para subconsultas. Los detalles sobre la compatibilidad con subconsultas se documentan en View parallel query execution plans.

Sintaxis

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

Ejemplos

Directiva pushdown:

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

Directiva de acceso compartido:

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

Hint en línea sin referencia a un bloque de consulta:

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