Hint

Si applica a: Databricks SQL Databricks Runtime

Suggerire approcci specifici per un piano di esecuzione generate.

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 partition come parametro.

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

  Ripartizione al numero specificato di partizioni usando le espressioni di partizionamento specificate. Accetta un numero partition, nomi column o entrambi come parameters.

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

  Ripartizione al numero specificato di partizioni usando le espressioni di partizionamento specificate. Accetta column nomi e un numero facoltativo partition come parameters.

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

  L'hint REBALANCE può essere usato per ribilanciare le partizioni di output dei risultati della query, in modo che ogni partition sia di dimensioni ragionevoli (non troppo piccole e non troppo grandi). Può accettare nomi di column come parameterse cercare di partition il risultato della query con questi columns. 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 un table, per evitare file troppo piccoli/grandi. Questo hint viene ignorato se AQE non è abilitato.

• column_name

  Nome esposto di un column o alias in base al quale ripartizionare o ribilanciare.

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

Suggerimenti Join

Join hint consentono di suggerire la strategia join che Databricks SQL dovrebbe utilizzare. Quando vengono specificati hint di strategia join diversi su entrambi i lati di un join, Databricks SQL assegna le priorità agli hint nell'ordine seguente: BROADCAST su MERGE su SHUFFLE_HASH su SHUFFLE_REPLICATE_NL. Quando entrambi i lati vengono specificati con l'hint BROADCAST o l'hint SHUFFLE_HASH, Databricks SQL seleziona il lato di costruzione in base al tipo di join e alle dimensioni delle relazioni. Poiché una determinata strategia potrebbe non supportare tutti i tipi join, non è garantito che Databricks SQL usi la strategia di join suggerita dal suggerimento.

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.

Join tipi di suggerimenti

• BROADCAST ( table_name )

  Usare broadcast join. Il lato join con il suggerimento viene trasmesso indipendentemente da autoBroadcastJoinThreshold. Se entrambe le parti del join hanno gli indizi di trasmissione, quella con la dimensione più ridotta (in base alle statistiche) viene trasmessa.

• MERGE ( table_name )

  Usare l'intercalazione per ordinare e unire join.

• SHUFFLE_HASH ( table_name )

  Usare l'hash casuale join. 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 un ciclo annidato "shuffle-and-replicate" join.

• table_name

  Nome esposto di un table o table-alias a cui si applica il suggerimento.

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) Vedere Ottimizzazione dell'asimmetria join usando suggerimenti di asimmetria per informazioni sul suggerimento SKEW.

Istruzioni correlate

• SELECT