Hint

Si applica a: Databricks SQL Databricks Runtime

Suggerire approcci specifici per generare un piano di esecuzione.

Sintassi

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

Hint di partizionamento

Gli hint di partizionamento consentono di suggerire una strategia di partizionamento che Azure Databricks deve seguire. COALESCEGli hint , REPARTITIONe REPARTITION_BY_RANGE sono supportati e sono equivalenti rispettivamente alle coalesceAPI del set di dati , repartitione repartitionByRange . Questi hint consentono di ottimizzare le prestazioni e controllare il numero di file di output. Quando vengono specificati più hint di partizionamento, più nodi vengono inseriti nel piano logico, ma l'hint più a sinistra viene selezionato dall'ottimizzatore.

Sintassi

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

Tipi di hint per il partizionamento

• COALESCE ( part_num )

  Ridurre il numero di partizioni al numero specificato di partizioni. Accetta un numero di partizione come parametro.

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

  Ripartizione al numero specificato di partizioni usando le espressioni di partizionamento specificate. Accetta un numero di partizione, nomi di colonna o entrambi come parametri.

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

  Ripartizione al numero specificato di partizioni usando le espressioni di partizionamento specificate. Accetta nomi di colonna e un numero di partizione facoltativo come parametri.

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

  L'hint REBALANCE può essere usato per ribilanciare le partizioni di output dei risultati della query, in modo che ogni partizione sia di dimensioni ragionevoli (non troppo piccole e non troppo grandi). Può accettare nomi di colonna come parametri e provare a partizionare il risultato della query in base a queste colonne. Si tratta di un'operazione ottimale: se sono presenti asimmetrie, Spark dividerà le partizioni asimmetriche, per rendere queste partizioni non troppo grandi. Questo hint è utile quando è necessario scrivere il risultato di questa query in una tabella, per evitare file troppo piccoli/grandi. Questo hint viene ignorato se AQE non è abilitato.

• column_name

  Nome esposto di una colonna o di un alias per ripartizionamento o ribilanciamento.

• part_num

  Valore letterale numero integrale. Numero di partizioni da suddividere in.

Esempi

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

Hint di join

Gli hint di join consentono di suggerire la strategia di join che Databricks SQL deve usare. Quando vengono specificati hint di strategia di join diversi su entrambi i lati di un join, Databricks SQL assegna le priorità agli hint nell'ordine seguente: BROADCAST over MERGE over SHUFFLE_HASH over SHUFFLE_REPLICATE_NL. Quando entrambi i lati vengono specificati con l'hint BROADCAST o l'hint SHUFFLE_HASH , Databricks SQL seleziona il lato di compilazione in base al tipo di join e alle dimensioni delle relazioni. Poiché una determinata strategia potrebbe non supportare tutti i tipi di join, Databricks SQL non garantisce l'uso della strategia di join suggerita dall'hint.

Sintassi

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

BROADCASTJOIN e MAPJOIN sono supportati come alias per BROADCAST.

SHUFFLE_MERGE e MERGEJOIN sono supportati come alias per MERGE.

Tipi di hint di join

• BROADCAST ( table_name )

  Usa join broadcast. Il lato join con l'hint viene trasmesso indipendentemente da autoBroadcastJoinThreshold. Se entrambi i lati del join hanno gli hint di trasmissione, quello con le dimensioni più piccole (in base alle statistiche) viene trasmesso.

• MERGE ( table_name )

  Usare l'ordinamento casuale merge join.

• SHUFFLE_HASH ( table_name )

  Usare l'hash join casuale. Se entrambi i lati hanno gli hint hash casuali, Databricks SQL sceglie il lato più piccolo (in base alle statistiche) come lato di compilazione.

• SHUFFLE_REPLICATE_NL ( table_name )

  Usare shuffle-and-replicate nested loop join.

• table_name

  Nome esposto di una tabella o di un alias di tabella a cui si applica l'hint.

Esempi

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

Hint di asimmetria

(Delta Lake) Per informazioni sull'hint, vedere Ottimizzazione dell'asimmetria SKEW dei join tramite hint di asimmetria.

Istruzioni correlate

• SELECT