Sugerencias

Se aplica a: Databricks SQL Databricks Runtime

Sugiera enfoques específicos para generar un plan de ejecución.

Sintaxis

/*+ { partition_hint | join_hint | skew_hint } [, ...] */

Sugerencias de creación de particiones

Las sugerencias de creación de particiones le permiten sugerir una estrategia de creación de particiones que debe seguir Azure Databricks. Se admiten las sugerencias COALESCE, REPARTITION y REPARTITION_BY_RANGE, y son equivalentes a las API de conjunto de datos coalesce, repartitiony repartitionByRange respectivamente. Estas sugerencias le ofrecen una manera de optimizar el rendimiento y controlar el número de archivos de salida. Cuando se especifican varias sugerencias de partición, se insertan varios nodos en el plan lógico, pero el optimizador elige la sugerencia situada más a la izquierda.

Sintaxis

partition_hint
  COALESCE ( part_num ) |
  REPARTITION ( { part_num | [ part_num , ] column_name [ , ...] } ) |
  REPARTITION_BY_RANGE ( column_name [, ...] [, part_num] ) |
  REBALANCE [ ( column_name [, ...] ) ]

Tipos de sugerencias de partición

• COALESCE ( part_num )

  Reduzca el número de particiones al número de particiones especificado. Toma un número de partición como parámetro.

• REPARTITION ( { part_num | [ part_num , ] column_name [ , ...] } )

  Volver a particionar el número especificado de particiones mediante las expresiones de partición especificadas. Toma un número de partición, nombres de columna o ambos como parámetros.

• REPARTITION_BY_RANGE ( column_name [, ...] [, part_num]

  Volver a particionar el número especificado de particiones mediante las expresiones de partición especificadas. Toma nombres de columna y un número de partición opcional como parámetros.

• REBALANCE [ ( column_name [, ...] ) ]

  La sugerencia REBALANCE se puede usar para reequilibrar las particiones de salida del resultado de la consulta, de modo que cada partición tenga un tamaño razonable (no demasiado pequeño ni demasiado grande). Puede tomar nombres de columna como parámetros e intentar dividir el resultado de la consulta entre estas columnas. Se trata de una regla de esfuerzo: si hay sesgos, Spark dividirá las particiones sesgadas para que estas particiones no sean demasiado grandes. Esta sugerencia es útil cuando necesita escribir el resultado de esta consulta en una tabla para evitar archivos demasiado pequeños o grandes. Esta sugerencia se omite si AQE no está habilitado.

• column_name

  Nombre expuesto de una columna o alias para volver a particionar o reequilibrar.

• part_num

  Un número integral literal. El número de particiones que se van a volver a particionar.

Ejemplos

> SELECT /*+ COALESCE(3) */ * FROM t;

> SELECT /*+ REPARTITION(3) */ * FROM t;

> SELECT /*+ REPARTITION(c) */ * FROM t;

> SELECT /*+ REPARTITION(3, c) */ * FROM t;

> SELECT /*+ REPARTITION_BY_RANGE(c) */ * FROM t;

> SELECT /*+ REPARTITION_BY_RANGE(3, c) */ * FROM t;

> SELECT /*+ REBALANCE */ * FROM t;

> SELECT /*+ REBALANCE(c) */ * FROM t;

-- When a column name has been occluded by an alias you must refere to it by the alias name.
> SELECT /*+ REBALANCE(d) */ * FROM t AS s(d);

-- multiple partitioning hints
> EXPLAIN EXTENDED SELECT /*+ REPARTITION(100), COALESCE(500), REPARTITION_BY_RANGE(3, c) */ * FROM t;
== Parsed Logical Plan ==
'UnresolvedHint REPARTITION, [100]
+- 'UnresolvedHint COALESCE, [500]
   +- 'UnresolvedHint REPARTITION_BY_RANGE, [3, 'c]
      +- 'Project [*]
         +- 'UnresolvedRelation [t]

== Analyzed Logical Plan ==
name: string, c: int
Repartition 100, true
+- Repartition 500, false
   +- RepartitionByExpression [c#30 ASC NULLS FIRST], 3
      +- Project [name#29, c#30]
         +- SubqueryAlias spark_catalog.default.t
            +- Relation[name#29,c#30] parquet

== Optimized Logical Plan ==
Repartition 100, true
+- Relation[name#29,c#30] parquet

== Physical Plan ==
Exchange RoundRobinPartitioning(100), false, [id=#121]
+- *(1) ColumnarToRow
   +- FileScan parquet default.t[name#29,c#30] Batched: true, DataFilters: [], Format: Parquet,
      Location: CatalogFileIndex[file:/spark/spark-warehouse/t], PartitionFilters: [],
      PushedFilters: [], ReadSchema: struct<name:string>

Sugerencias de combinación

Las sugerencias de combinación permiten sugerir la estrategia de combinación que Databricks SQL debe utilizar. Cuando se especifican diferentes sugerencias de estrategia de combinación en ambos lados de una combinación, Databricks SQL prioriza las sugerencias en el orden siguiente: BROADCASTsobre MERGE sobre SHUFFLE_HASH sobre SHUFFLE_REPLICATE_NL. Cuando se especifican ambos lados con la sugerencia BROADCAST o la sugerencia SHUFFLE_HASH, Databricks SQL elige el lado de compilación en función del tipo de combinación y los tamaños de las relaciones. Como una estrategia determinada puede no admitir todos los tipos de combinación, Databricks SQL no garantiza el uso de la estrategia de combinación propuesta por la sugerencia.

Sintaxis

join_hint
  BROADCAST ( table_name ) |
  MERGE ( table_name ) |
  SHUFFLE_HASH ( table_name ) |
  SHUFFLE_REPLICATE_NL ( table_name )

BROADCASTJOIN y MAPJOIN se admiten como alias para BROADCAST.

SHUFFLE_MERGE y MERGEJOIN se admiten como alias para MERGE.

Tipos de sugerencias de combinación

• BROADCAST ( table_name )

  Use la combinación de difusión. El lado de combinación con la sugerencia se difunde independientemente de autoBroadcastJoinThreshold. Si ambos lados de la combinación tienen las sugerencias de difusión, se difunde el de menor tamaño (según las estadísticas).

• MERGE ( table_name )

  Use la ordenación aleatoria de la combinación.

• SHUFFLE_HASH ( table_name )

  Use la combinación hash aleatoria. Si ambos lados tienen las sugerencias hash aleatorias, Databricks SQL elige el lado más pequeño (en función de las estadísticas) como lado de compilación.

• SHUFFLE_REPLICATE_NL ( table_name )

  Use la combinación de bucles anidados de ordenar aleatoriamente y replicar.

• table_name

  Nombre expuesto de una tabla o alias de tabla al que se aplica la sugerencia.

Ejemplos

-- Join Hints for broadcast join
> SELECT /*+ BROADCAST(t1) */ * FROM t1 INNER JOIN t2 ON t1.key = t2.key;
> SELECT /*+ BROADCASTJOIN (t1) */ * FROM t1 left JOIN t2 ON t1.key = t2.key;
> SELECT /*+ MAPJOIN(t2) */ * FROM t1 right JOIN t2 ON t1.key = t2.key;

-- Join Hints for shuffle sort merge join
> SELECT /*+ SHUFFLE_MERGE(t1) */ * FROM t1 INNER JOIN t2 ON t1.key = t2.key;
> SELECT /*+ MERGEJOIN(t2) */ * FROM t1 INNER JOIN t2 ON t1.key = t2.key;
> SELECT /*+ MERGE(t1) */ * FROM t1 INNER JOIN t2 ON t1.key = t2.key;

-- Join Hints for shuffle hash join
> SELECT /*+ SHUFFLE_HASH(t1) */ * FROM t1 INNER JOIN t2 ON t1.key = t2.key;

-- Join Hints for shuffle-and-replicate nested loop join
> SELECT /*+ SHUFFLE_REPLICATE_NL(t1) */ * FROM t1 INNER JOIN t2 ON t1.key = t2.key;

-- When different join strategy hints are specified on both sides of a join, Databricks SQL
-- prioritizes the BROADCAST hint over the MERGE hint over the SHUFFLE_HASH hint
-- over the SHUFFLE_REPLICATE_NL hint.
-- Databricks SQL will issue Warning in the following example
-- org.apache.spark.sql.catalyst.analysis.HintErrorLogger: Hint (strategy=merge)
-- is overridden by another hint and will not take effect.
> SELECT /*+ BROADCAST(t1), MERGE(t1, t2) */ * FROM t1 INNER JOIN t2 ON t1.key = t2.key;

-- When a table name is occluded by an alias you must use the alias name in the hint
> SELECT /*+ BROADCAST(t1), MERGE(s1, s2) */ * FROM t1 AS s1 INNER JOIN t2 AS s2 ON s1.key = s2.key;

Sugerencias de sesgo

(Delta Lake) Vea Optimización de la combinación de sesgos mediante sugerencias de sesgo para obtener información sobre la sugerencia SKEW.

Instrucciones relacionadas

• SELECT