Indicateurs

S’applique à : Databricks SQL Databricks Runtime

Suggèrent des approches spécifiques pour générer un plan d’exécution.

Syntaxe

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

Indicateurs de partitionnement

Les indicateurs de partitionnement vous permettent de suggérer une stratégie de partitionnement qu’Azure Databricks doit suivre. COALESCE, REPARTITION et les indicateurs REPARTITION_BY_RANGE sont pris en charge et sont équivalents à coalesce, repartition et les API de DataSet repartitionByRange, respectivement. Ces indicateurs vous permettent de régler les performances et de contrôler le nombre de fichiers de sortie. Lorsque plusieurs indicateurs de partitionnement sont spécifiés, plusieurs nœuds sont insérés dans le plan logique, mais l’indicateur le plus à gauche est choisi par l’optimiseur.

Syntaxe

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

Types d’indicateurs de partitionnement

• COALESCE ( part_num )

  Réduire le nombre de partitions au nombre spécifié de partitions. Il accepte un numéro de partition en tant que paramètre.

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

  Repartitionner le nombre spécifié de partitions à l’aide des expressions de partitionnement spécifiées. Il accepte un numéro de partition, des noms de colonnes, ou les deux en tant que paramètres.

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

  Repartitionner le nombre spécifié de partitions à l’aide des expressions de partitionnement spécifiées. Il accepte les noms de colonnes et un numéro de partition facultatif en tant que paramètres.

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

  L’indicateur REBALANCE peut être utilisé pour rééquilibrer les partitions de sortie des résultats de la requête, de façon à ce que chaque partition soit d’une taille raisonnable (ni trop petite ni trop grande). Il accepte des noms de colonne comme paramètres et essaye de partitionner le résultat de la requête en fonction de ces colonnes. Il s’agit d’un « best effort » : s’il existe des asymétries, Spark fractionne les partitions inclinées, afin qu’elles soient de la bonne taille. Cet indicateur est utile lorsque vous devez écrire le résultat de cette requête dans une table, afin d’éviter d’avoir un fichier trop petit/grand. Cet indicateur est ignoré si AQE n’est pas activé.

• column_name

  Le nom exposé d’une colonne ou d’un alias à repartitionner ou rééquilibrer par.

• part_num

  Un littéral de nombre intégral. Le nombre de partitions à repartitionner.

Exemples

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

Indicateurs de jointure

Les indicateurs de jointure vous permettent de suggérer la stratégie de jointure que Databricks SQL doit utiliser. Lorsque différents indicateurs de stratégie de jointure sont spécifiés des deux côtés d’une jointure, Databricks SQL hiérarchise les indicateurs dans l’ordre suivant : BROADCAST, MERGE, SHUFFLE_HASH, SHUFFLE_REPLICATE_NL. Lorsque les deux côtés sont spécifiés avec l’indicateur BROADCAST ou SHUFFLE_HASH, Databricks SQL sélectionne le côté de build en fonction du type de jointure et de la taille des relations. Étant donné qu’une stratégie donnée peut ne pas prendre en charge tous les types de jointure, Databricks SQL ne garantit pas l’utilisation de la stratégie de jointure suggérée par l’indicateur.

Syntaxe

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

BROADCASTJOIN et MAPJOIN sont pris en charge en tant qu’alias pour BROADCAST.

SHUFFLE_MERGE et MERGEJOIN sont pris en charge en tant qu’alias pour MERGE.

Types d’indicateurs de jointure

• BROADCAST ( table_name )

  Utilisez la jointure de diffusion. Le côté de la jointure avec l’indicateur est la diffusion, indépendamment de autoBroadcastJoinThreshold. Si les deux côtés de la jointure ont les indicateurs de diffusion, celui dont la taille est inférieure (selon les statistiques) est broadcast.

• MERGE ( table_name )

  Utilisez la jointure de fusion de tri aléatoire.

• SHUFFLE_HASH ( table_name )

  Utilisez la jointure de hachage aléatoire. Si les deux côtés possèdent les indicateurs de hachage aléatoires, Databricks SQL choisit le côté le plus petit (en fonction des statistiques) comme côté pour la build.

• SHUFFLE_REPLICATE_NL ( table_name )

  Utilisez la jointure de boucle imbriquée de lecture aléatoire et de réplication.

• table_name

  Le nom exposé d’une table ou d’un alias de table auquel l’indicateur s’applique.

Exemples

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

Indicateurs d’asymétrie

(Delta Lake) Consultez Optimisation de la jointure d’asymétrie à l’aide d’indicateurs d’asymétrie pour plus d’informations sur l’indicateur SKEW.

Instructions connexes

• SELECT